Smart `= new Smart(security);`



Nessus Integration API for Happy .NET Developer
2011-08-09T01:19:00.000-07:00
[About NetNessus]

You can now integrate Nessus  Services into your own enterprise security environment, Nessus originally  provided RPCXML API for Nessus integration (actually it is more like XML  over HTTPS), working with this API is not very productive and requires going  back to the API documents very often, it is not even productive to integrate  into a security solution developed using a certain development  platform.

The NetNessus API is an integration  layer used to provide abstraction to the Nessus XML API, using .NET and the  power of WCF, anyone can now integrate Nessus into their enterprise security  solution, if combined with WF, it can even be more productive, some of the  solutions that can be done for example could be a remote administration and  management of Nessus from mobile devices, a dashboard for management, through  any web portal or even re-brand Nessus :)

[The API]

The API is simple, in the download section you will have a  very simple web application for demonstration + API (you will need ASP.NET 4.0  & VS 2010), this is the initial version, so it is not complete and it  contains the following operations:

Login (Login operation, this  generates a cookie session for use with operations the need  authentication)
getReports (list available  reports)
getScans (list current active  scans)
getPolicies (list stored scan  policies)
startScan (start a  scan)
Here are screens of the demo ASP.NET web application

The API are available in two source files:

NessusAPI.CS, contains the API
NessusDataTypes.CS, contains data  types that encapsulates XML messages returned from Nessus.

The  methods above do the work needed to parse the results back from Nessus XML,  however, the following method is responsible for posting the data:



private XDocument nessusCommander(string httpParams, string urlData)

    {

        Util util = new Util();



        string uri = util.GetNessusRpcUrl() + urlData;



        System.Net.ServicePointManager.ServerCertificateValidationCallback += 

                  new RemoteCertificateValidationCallback(checkPolicy);



        HttpWebRequest request = (HttpWebRequest)

        WebRequest.Create(uri);

        request.KeepAlive = true;

        request.ProtocolVersion = HttpVersion.Version10;

        request.Method = "POST";



        byte[] postBytes = Encoding.ASCII.GetBytes(httpParams);



        request.ContentType = "application/x-www-form-urlencoded";

        request.ContentLength = postBytes.Length;

        Stream requestStream = request.GetRequestStream();



        requestStream.Write(postBytes, 0, postBytes.Length);

        requestStream.Close();



        XDocument xmldoc;

        // Watch for this, 

        // Nessus wont return XML in case of an error (like authentication)

        using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)

        {

            Stream strm = response.GetResponseStream();



            StreamReader reader = new StreamReader(strm);

            xmldoc = XDocument.Parse(reader.ReadToEnd());

        }



        return xmldoc;

    }
[Download]


Agile
2009-11-21T09:44:00.000-08:00
I went to the many resources I could find on the web about Agile, and found few good resources that helped me a lot in exploring the concepts and techniques. To be honest, I collected many resources then decided that they won't do good, because all I found at first was on.... paper, or a book....Ok, but how all this applied in real life? I found that SCRUM can be used in other industries, other than software (it is really related to lean management), so I did more research on the topic in order to find theory "applied", and I found a couple of great resources that can really show you how Agile is applied (with tools, code and all the great stuff that drives us crazy at the end of the project)

Following are "Autumn of Agile" screen casts, after watching them, try to check other related topics, like Enterprise library, Team Foundation Server, ORM Technologies (I will be posting few resources about the last one), and how they can help in managing projects in an "Agile" Environment...Enjoy!

Autumn of Agile Screencast Series:
Downloads Title
Video | No Code Iteration -1: Intro to Agile
Video | No Code Iteration 0 - Part A: Organizing Requirements
Video | No Code Iteration 0 - Part B: Estimating Tasks and Setting up CI Server
Video | Code Iteration 1 - Part A: Using TDD to drive our first User Story
Video | Code Iteration 1 - Part B: Integrating with Rhino Tools and ASP.NET MVC frameworks
Video | Code Iteration 1 - Part C: Our First Controller and View in ASP.NET MVC
Video | Code Iteration 1 - Part D: Refactoring to Eliminate Technical Debt

This previous tutorial is great in clearing the concepts of Agile with a practical step-by-step demonstration to build a real project, created by 
Stephen A. Bohlen 

For some Agile OOP (actually they are just OOP concepts, but good to see them from Agile perspective), you can watch Venkat Subramaniam on dnrTV talking about Fundamentals of Agile Design:
Part 1 of Fundamentals of Agile Design
Part 2 of Fundamentals of Agile Design



SharePoint 2010 Beta is here...
2009-11-19T00:41:00.000-08:00
Yesterday, SharePoint 2010 team blog announced the BEAT release of MOSS 2010, it can be downloaded from this direct link http://sharepoint2010.microsoft.com/try-it/Pages/Trial.aspx, let me say that the HW and SW requirements are a little bit expensive for me... the requierments are listed here http://technet.microsoft.com/en-us/library/cc262485(office.14).aspx

I decided that I won’t be downloading the BETA today till I have a descent 64-bit hardware, and decided to go directly to the "getting started" section to dig deeper into the resources (http://technet.microsoft.com/en-us/sharepoint/ee518660.aspx)

Enjoy...


WCF - Windows Communication Foundation
2009-11-15T03:39:00.000-08:00
Get started with WCF quickly and easily, here are two great resources for you:
First, dasBlonde WCF Webcasts:
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 01 of 15): Overview
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 02 of 15): Contracts
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 03 of 15): Contract Versioning
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 04 of 15): Exceptions and Faults
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 05 of 15): Bindings
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 06 of 15): Hosting
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 07 of 15): Messaging Patterns
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 08 of 15): Instancing Modes
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 09 of 15): Concurrency, Throughput, and Throttling
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 10 of 15): Security Fundamentals
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 11 of 15): Federated Security
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 12 of 15): Reliable Messaging
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 13 of 15): Transactions
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 14 of 15): Message Queuing
MSDN Webcast: Windows Communication Foundation Top to Bottom (Part 15 of 15): Extensibility

Second, I would strongly recomend Aaron Skonnard screencasts from Pluralsight, not just WCF, but also WCF RESTful starter kit preview 1 and 2, which is great, make sure to visit the site for new screencasts:

Creating your first WCF client, Learn how to create your first WCF client application. You'll see how to add a service reference to your client project, use the generated client classes and configuration file, and actually invoke the service operations and process the results.
Configuring service references, Learn how to configure client-side service references with different settings. You'll see how to use service reference configuration editor within Visual Studio 2008 to customize various code-generation settings.
Getting started with the WCF REST Starter Kit, Learn how to get started with the new WCF REST Starter Kit. You'll see how to install the WCF REST Starter Kit on your machine, navigate the documentation, samples, and project templates, and you'll see how to quickly get started with a simple RESTful service implementation.
A lap around the new API extensions - Part 1, Learn how to use some of the new APIs that come with the WCF REST Starter Kit. You'll see how to use various classes and extension methods found in Microsoft.ServiceModel.Web including [WebHelp], [WebCache], WebProtocolException, WebServiceHost2, and more.
A lap around the new API extensions - Part 2, Learn how to use some of the new APIs that come with the WCF REST Starter Kit. You'll see how to take advantage of the new RequestInterceptor extensibility point made possible by WebServiceHost2.
Resource singleton services, Learn how to create a simple resource singleton service using the WCF REST Starter Kit. You'll see how to use the Resource Singleton Service project template to create a sample implementation that you'll customize to expose your favorite movie information as a singleton resource, and then you'll test the service using Fiddler.
Resource collection services, Learn how to implement resource collection services using the WCF REST Starter Kit. You'll see how to use the Resource Collection Service project template to create a sample implementation that exposes a collection of bookmarks, and then you'll test the service using Fiddler.
Atom feed services, Learn how to implement a simple Atom feed service using the WCF REST Starter Kit. You'll see how to use the Atom Feed Service project template, customize the project, and test the feed within Internet Explorer.
AtomPub services, Learn how to implement a standard AtomPub service using the WCF REST Starter Kit. You'll see how to use the AtomPub Service project template, customize the project, and test the AtomPub service within Internet Explorer and Fiddler.
HTTP Plain XML (POX) Services, Learn how to implement HTTP plain XML services (POX) using the WCF REST Starter Kit. These services don't have to follow the RESTful constraints -- they simply define operations that send/receive XML payloads.
Multiple resource representations, Learn how to use the WCF REST Starter Kit to implement RESTful services that support a variety of different resource representation formats. We'll see how to support both XML and JSON, push-style Streams, and URL-encoded input.
Implementing X-HTTP-Method-Override, Learn how to implement X-HTTP-Method-Override in your WCF RESTful services using the new WCF REST Starter Kit. This video shows you how to build a RequestInterceptor class that intercepts the incoming messages to perform the X-HTTP-Method-Override logic.
Calling services asynchronously with WCF, Learn how to invoke Web services asynchronously with WCF in order to avoid tying up your main application thread.
Hosting WCF services in Windows Services, Learn how to host your WCF services within a traditional Windows Service when you can't use (or don't want to use) IIS hosting techniques for whatever reason.
Configuring WAS for TCP endpoints, Learn how to configure Windows Process Activation Service (WAS) for TCP-based activation, making it possible for you to host your WCF service in IIS with TCP-based endpoints.
Configuring Bindings, Learn how to configure bindings on your WCF endpoints, which will allow you to customize the precise communication details you wish to support on your service.
Configuring services with behaviors, Learn how to configure your WCF services with behaviors, which will allow you to customize different aspects of the runtime execution "behavior".
Configuring MEX endpoints, Learn how to configure your WCF services with Metadata Exchange (MEX) endpoints - both over HTTP and TCP - allowing consumers to automatically retrieve metadata from your services at runtime.
Building RESTful Services with WCF, Learn how to build a RESTful service with WCF, converting a previously created WCF service to support a RESTful interface.
Building RESTful Services with WCF (Part 2), This screencasts continues to guide the viewer through how to build a RESTful service with WCF, simplifying the IIS hosting of the service.
Calling RESTful Services with WCF, This screencast introduces developers to the client-side experience for using WCF to consume RESTful services. You'll see how to use the new WebChannelFactory class to create WCF channels that know how to map method calls into traditional HTTP operations (GET, POST, PUT, and DELETE).
Ajax-enabling your WCF services, This screencast guides the viewer through the process of Ajax-enabling your WCF services, allowing you to easily consume them from within your Ajax client pages.
Using HttpClient to consume Twitter in under 3 minutes, This screencast shows you how to use the new HttpClient class found in the WCF REST Starter Kit (Preview 2) to build a console application that retrieves Twitter statuses and updates Twitter statues (using the Twitter REST API), and it only takes 3 minutes to do it!
Getting started with the WCF REST Starter Kit Preview 2, This screencast shows you how to get started with the new version of the WCF REST Starter Kit (Preview 2) that you can download now from CodePlex. It shows how to use the starter kit to create a simple REST service, along with a simple client to consume it.
Consuming REST services with HttpClient, This screencast shows you how to use the new HttpClient API (found in the WCF REST Starter Kit Preview 2) to build a Twitter client application against the Twitter REST API. It shows how to use several of the operations on the Twitter REST service.
HttpClient: Query string and form input, This screencast shows you how to manage query string and form input required by RESTful services on the Web by using some of the new features in the WCF REST Starter Kit Preview 2. The example shows how to send this type of input into the Twitter REST API.

HttpClient: Processing message content, This screencast shows you how to process different types of messages that you might get back from RESTful services on the Web. It shows how to use XLinq, DataContractSerializer, and XmlSerializer, and it shows how to process XML, Atom, and JSON messages.


Happy programming


SharePoint Walkthrough – Playing with features (Step 3)
2009-10-04T04:55:00.000-07:00
This is the third and final part of our walkthrough – Playing with features, in the previous tutorial, we created an instance of a document library, added a web part page to it and finally added two web parts to this page, what is left to be done is to connect the two web parts together, to do this we will add an event receiver class to our last feature, that is the feature that creates the web part page instance, using event receivers, we can connect the two web parts and do other custom actions, for example, when the feature is disabled, we want to be able to delete the document library.

Step 3 – Connecting the web parts

Open VS 2008 and start where we left off in our last step (the code for the last tutorial can be downloaded here), we will add an event receiver class (C#) to our ProductsPage feature, switch to the Solution Explorer, right click the ProductsPage folder and add new class to this folder, name it “ProductsPageHandler.cs”, click Add.

The class generated is as follows:

   1:  namespace Walkthrough1.ProductsPage
   2:  {
   3:      class ProductsPageHandler
   4:      {
   5:      }
   6:  }

We need to modify it as follows (I’ll explain next):

   1:  using System;
   2:  using System.Security.Permissions;
   3:  using System.Runtime.InteropServices;
   4:  using Microsoft.SharePoint;
   5:  using Microsoft.SharePoint.WebPartPages;
   6:  using System.Web.UI.WebControls.WebParts;
   7:   
   8:  namespace Walkthrough1.ProductsPage
   9:  {
  10:      [CLSCompliant(false)]
  11:      [Guid("229de50f-4cef-4d1c-9b5c-cabbd0cc20b5")]
  12:      public class ProductsPageHandler : SPFeatureReceiver
  13:      {
  14:          public override void FeatureActivated(SPFeatureReceiverProperties properties)
  15:          {
  16:              using (SPWeb web = properties.Feature.Parent as SPWeb)
  17:              {
  18:                  SPFile file = web.GetFile(web.Url + "/Lists/Products/MyProducts.aspx");
  19:                  SPLimitedWebPartManager webPartManager = file.GetLimitedWebPartManager(System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
  20:   
  21:                  // We know this is the first web part, however, we should try to reference the web part in a better way and not to
  22:                  // count on order, same for the connections, although we know we have one connection interface
  23:                  // I could have added web parts using code instead of feature.
  24:                  // One bug migh come along is when trying to re-activate the feature, the list will remain and
  25:                  // the page would be UPDATED with extra versions of the web parts
  26:   
  27:                  System.Web.UI.WebControls.WebParts.WebPart wpLearningStyle = webPartManager.WebParts[0];
  28:                  System.Web.UI.WebControls.WebParts.WebPart wpStyleDescription = webPartManager.WebParts[1];
  29:   
  30:                  ProviderConnectionPoint cnLearnningStyle = webPartManager.GetProviderConnectionPoints(wpLearningStyle)[0];
  31:                  ConsumerConnectionPoint cnLearningDescription = webPartManager.GetConsumerConnectionPoints(wpStyleDescription)[0];
  32:   
  33:                  webPartManager.SPConnectWebParts(wpLearningStyle, cnLearnningStyle, wpStyleDescription, cnLearningDescription);
  34:   
  35:              }
  36:          }
  37:   
  38:          public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
  39:          {
  40:              // When the feature is deactivated, I need to delete the document library
  41:              using (SPWeb web = properties.Feature.Parent as SPWeb)
  42:              {
  43:                  try
  44:                  {
  45:                      SPList list = web.Lists["Products"];
  46:                      list.Delete();
  47:                      list.Update();
  48:                  }
  49:                  catch (Exception ex)
  50:                  {
  51:                      // Well, this exception means list do not exist
  52:                  }
  53:              }
  54:          }
  55:   
  56:          public override void FeatureInstalled(SPFeatureReceiverProperties properties)
  57:          {
  58:          }
  59:   
  60:          public override void FeatureUninstalling(SPFeatureReceiverProperties properties)
  61:          {
  62:          }
  63:      }
  64:  }

First of all, there is no way for WSS to know that this event receiver is associated with our feature, we need to link them together, and the easiest way to accomplish this is through the GUID attribute of the class:

   1:  [Guid("229de50f-4cef-4d1c-9b5c-cabbd0cc20b5")]

I copied this Guid from the feature.xml under ProductsPage feature; this is the same as the Id attribute of the >Feature< element. This would differ if you are working on your own and not copying the uploaded solution files, so you need to change it if you are following with your own source code.

Next modification is the class itself, we need to make it public and inherit from the class SPFeatureReceiver, the most important method to override is the FeatureActivated method, this method will be called once our feature is deployed and activated (our web part page instance), this means we have a page with two web parts ready to go.

To work with web part page we need to use the SPFile class, using this class I can obtain a web part manager (SPLimitedWebPartManager) with a shared scope, this is the same scope you use when you say “Modify shared web part” on the WSS UI web interface. Using our web part manager, we can access our web parts through indexer; finally we used ProviderConnectionPoint and ConsumerConnectionPoint classes to connect the web parts.

Note: If you are writing the code yourself, you might get confused by the reference resolve error, the error is for the WebPart class specifically, you need to determin which WebPart class you are referencing, the one in the Microsoft.SharePoint.WebPartPages name space or the one in the System.Web.UI.WebControls.WebParts name space. As you can see from the code above, we used the classes from the System.Web.UI.WebControls.WebParts name space (WebPart, ConsumerConnectionPoint and ProviderConnetionPoint)

Thoughts: As you see from the code, we need a better way (than indexers) to access web parts and connection points, and this is what the code comments is all about

The FeatureDeactivating() method is just to demonstrate what you can do with an event handler, here in our example, we are deleting the list once we deactivate the feature, please note that the features set in our solution needs to be installed and deactivated in order, so, if you try to activate this feature again after it was deactivated, it won’t work, because the list is deleted and there is no MyPage.aspx to work on, you can enhance the code further to add better logic based on features.

Thoughts: You can work with this code by adding more event handlers to the remaining features, enhance the activation/deactivation of features, group certain features into one features (although VSeWSS 1.3 will overwrite your work and you need to do much manually).

Make sure to delete the previously created document library first, then Build the solution and press F5 to run it, check if the web parts are connected by selecting products.

Hope you enjoyed this tutorial, drop me email if you have any questions on : nader_shalabi@hotmail.com

[Download source code]


SharePoint Walkthrough – Playing with features (Step 2)
2009-09-30T05:41:00.000-07:00
This is the second part of our walkthrough, in the previous step we created two connectable web parts, installed, connected and tested the web parts. In this tutorial, we will create a feature, that once activated, will create a document library, this is an easy step and VSeWSS takes care of much of the XML editing work for you, next however is the tricky part, we want to add a web part page, more, we want to add the two web parts we created in the first step to this page, so let’s get started.

Step 2 – Build the Document Library, Add Web Part Page, Add Web Parts to the Web Part Page

Create a document library instance

Open VS 2008 and start with the project we created in our first step, you can also pick up the first step code here. What we will do now is to create a feature that once activated will create a document library, so right click the project node in solution explorer and add a new item, select the List Instance from SharePoint category, name it ProductsLibrary:



The create list instance dialog shows up, select the Document Library template and click Ok:



That’s it! We need to tweak certain things:
Rename the ProductsLibrary Instance folder in the WSP View to ProductsLibrary.
Open the feature.xml file under ProductsLibrary node and modify the Title attribute in element and add a Description attribute (Title="Products Library Instance" Description="Creates a document library named Products").
Open the “ProductsLibrary\instance.xml” file and change the element attributes:
Description="Pages for our products"
OnQuickLaunch="True"
Title="Products" 
Url="Lists/Products"
The OnQuickLaunch attribute allows us to show the document library in the quick launch list. Save, build and press F5 or deploy from build menu, then, open the site in you debug settings and see if the list is created, mine shows this:



Add a web part page to the created list (document library) instanc

Let’s decompose this further:
Create a web part page instance
Ad two web parts (previously created) to the page instance
There is no template in VSeWSS 1.3 to add a web part page instance, the right way to create a web part page instance is by adding a Module (according to MSDN : http://msdn.microsoft.com/en-us/library/ms462994.aspx).

Right click the project node and add a Module from the SharePoint category, name it ProductsPage:



This will add two files, a Module.xml file and sample.txt file, delete the sample.txt file from the solution explorer, then go to the WSP View and click the refresh button. 
Open the feature.xml file under ProductsPage node and modify the element attributes, title and description (Title="Products Page Instance" Description="Creates an instance of a web part page"). 
Next open the Module .xml under ProductsPage under ProductsPage in WSP View, this file contains the elements describing the files that will need to be created and references their templates, currently the file looks something like this:

   1:  <Elements Id="8df75de2-ba12-465a-9bd3-3d2419daa9dc" xmlns="http://schemas.microsoft.com/sharepoint/">
   2:    <Module Name="ProductsPage">
   3:      <File Path="sample.txt" Url="sample.txt" />
   4:    </Module>
   5:  </Elements>

Sample.txt is the file added by the VSeWSS template and we already deleted it, delete the <File> element. Now we need to specify the template file for the web part page, I already took a shortcut on this, instead of writing the file from scratch, I took one from SharePoint web part page templates, go to the 12 folder, specifically “[DRIVE]:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\1033\STS\DOCTEMP\SMARTPGS”, you can pick any of the files, however, I decided to take the spstd3.aspx file, copy this file to your desktop and open in it in visual studio and look for this code:

   1:  <WebPartPages:WebPartZone runat="server" Title="loc:Header" ID="Header" FrameType="TitleBarOnly"/>

This is a web part zone, and we will use it to add our web parts to, let’s start, close the file and go to your desktop or where you copied the file and rename it to products.aspx, the right click on the ProductsPage folder in solution explorer and add existing item, pick up the products.aspx file and click Add, this is how your solution explorer should look like:



Go back to the feature.xml file under ProductsPage in WSP View and modify it by adding <ElementFile> element to <ElemenetManifests> node:

   1:  <ElementManifests>
   2:      <ElementManifest Location="ProductsPage\Module.xml" />
   3:      <ElementFile Location="ProductsPage\products.aspx.aspx" />
   4:  </ElementManifests>

This is how we will reference our file in this feature, now go back to the Module.xml file and modify it to look something like this (The GUIDs will be different than the one you have)

   1:  <?xml version="1.0" encoding="utf-8"?>
   2:  <Elements Id="8df75de2-ba12-465a-9bd3-3d2419daa9dc" xmlns="http://schemas.microsoft.com/sharepoint/">
   3:    <Module Name="ProductsPage" Url="Lists/Products">
   4:      <File Path="products.aspx" Url="products.aspx" Name="MyProducts.aspx" Type="GhostableInLibrary" />
   5:    </Module>
   6:  </Elements>

When I tried to do this first time I was really confused, the list will not copy the file you specify here (products.aspx) it will create a new file from it, the Url attribute in the <File> element tells the list the source from which the list will create instances, the Name attributes is the name of the new file, confused enough? The Url in the <module> element specify the list that will be used to create the web part page, you can find the value specified in the instance.xml file under the feature that creates the document library, in our case ProductsLibrary, refresh the WSP View and products.aspx page should be under the feature node:



This way we created the web part page instance, build the project and test it, this is my output, a document library with one web part page instance:



Thoughts: This is a great feature for many reasons, most important is to be able to extend the publishing features in MOSS 2007 by provisioning content through custom code (this can be achieved by code, but as long as it can be done with code maintenance, why not). Picking a scenario would be generating content from external sources on the fly and customize this content without any human intervention.

Open the web part page, you will find a blank page, but this is not true, you added all the features of SharePoint to this page, like the navigation, integration with SharePoint security, etc…, this is a powerful feature and a great canvas to start with. From the Site Actions menu, click Edit Page to work in Edit mode:



Note the web part zones this page defines, we will add the web parts to the Header web part zone, Click on Save and Stop Editing to move on to adding web parts to this page.
To add web through feature, we will continue to use the module feature we created, open the module.xml file and modify it to look like this (it will be different on your machine and I will tell you how to do it):

   1:  <?xml version="1.0" encoding="utf-8"?>
   2:  <Elements Id="8df75de2-ba12-465a-9bd3-3d2419daa9dc" xmlns="http://schemas.microsoft.com/sharepoint/">
   3:    <Module Name="ProductsPage" Url="Lists/Products">
   4:      <File Path="products.aspx" Url="products.aspx" Name="MyProducts.aspx" Type="GhostableInLibrary">
   5:        <AllUsersWebPart WebPartZoneID="Header" WebPartOrder="1">
   6:          <![CDATA[
   7:          <webParts>
   8:    <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
   9:      <metaData>
  10:        <!--
  11:        The following Guid is used as a reference to the web part class, 
  12:        and it will be automatically replaced with actual type name at deployment time.
  13:        -->
  14:        <type name="Walkthrough1.ProductsList, Walkthrough1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=368358217c045f14" />
  15:        <importErrorMessage>Cannot import ProductsList Web Part.</importErrorMessage>
  16:      </metaData>
  17:      <data>
  18:        <properties>
  19:          <property name="Title" type="string">Products List</property>
  20:          <property name="Description" type="string">Displays list of products</property>
  21:        </properties>
  22:      </data>
  23:    </webPart>
  24:  </webParts>
  25:          ]]>
  26:        </AllUsersWebPart>
  27:        <AllUsersWebPart WebPartZoneID="Header" WebPartOrder="2">
  28:          <![CDATA[
  29:          <webParts>
  30:    <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
  31:      <metaData>
  32:        <!--
  33:        The following Guid is used as a reference to the web part class, 
  34:        and it will be automatically replaced with actual type name at deployment time.
  35:        -->
  36:        <type name="Walkthrough1.ProductDescription, Walkthrough1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=368358217c045f14" />
  37:        <importErrorMessage>Cannot import ProductDescription Web Part.</importErrorMessage>
  38:      </metaData>
  39:      <data>
  40:        <properties>
  41:          <property name="Title" type="string">Product Description</property>
  42:          <property name="Description" type="string">Displays the description of a product from the products list web part</property>
  43:        </properties>
  44:      </data>
  45:    </webPart>
  46:  </webParts>
  47:          ]]>
  48:        </AllUsersWebPart>
  49:      </File>
  50:    </Module>
  51:  </Elements>

As you can see, I added the web parts using the <AllUsersWebPart> element, the attributes specify where the web part should appear and it’s order. The tricky part is getting the CDATA content, if you open (in solution explorer) the ProductsList.webpart file, you will find similar content to the one in the first CDATA section:

   1:  <?xml version="1.0" encoding="utf-8"?>
   2:  <webParts>
   3:    <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
   4:      <metaData>
   5:        <!--
   6:        The following Guid is used as a reference to the web part class, 
   7:        and it will be automatically replaced with actual type name at deployment time.
   8:        -->
   9:        <type name="c9c9e1af-8b05-4ed7-92b7-63194e872f1f" />
  10:        <importErrorMessage>Cannot import ProductsList Web Part.</importErrorMessage>
  11:      </metaData>
  12:      <data>
  13:        <properties>
  14:          <property name="Title" type="string">Products List</property>
  15:          <property name="Description" type="string">Displays list of products</property>
  16:        </properties>
  17:      </data>
  18:    </webPart>
  19:  </webParts>

However, the <type> element contains a GUID to the type, this is replaced when the web part is installed with the real type, to get it, go to the site’s web part gallery (where we used to test our project) and click on the web parts edit icon:



Then click on the View XML item:



And here you go! The full XML data that needs to go into the CDATA section:



Now build and deploy the solution, go to the Products library and open the MyProducts.aspx page, you will find the web parts deployed:



In the next step we will show how to connect the web parts.

Thoughts: This can be done (creating a page and adding web parts to it) by code, but to do this in a feature is yet another great benefit and added flexibility. How it can be done by code? Using event receivers, which I will cover in my next tutorial.

[Download source code]



SharePoint Walkthrough – Playing with features (Step 1)
2009-09-29T02:18:00.000-07:00
In this tutorial, we want to create a set of features that:
Creates a document library.
Creates a web part page instance in the document library.
Provision the web part page by adding two web parts to the page.
Connect the two web parts in the web part page instance with web part connections.
We will use Visual Studio 2008 and VSeWSS 1.3, so let's get started.

Step 1 – Write the web parts

Let's start by creating two connectable web parts, the first web parts will have a list of products, the second web part will display description text for the selected product in the first web part through web part connection, fire up visual studio 2008 and create new project, pick up the Empty project template from SharePoint projects type list:



Select "Full Trust (Deploy to GAC)" from the "Select Trust Level" dialog box:



We will write some code that won't work with partial trust deployment. Hit Ok.
Building connectable web parts is easy, we need first to agree on the connection interface between the web parts and what we are passing, here it is fairly simple, we are passing description string, so our interface will look something like this:

   1:  public interface IProductDescription
   2:  {
   3:      // Our data is goes here
   4:      string ProductDescription { get; }
   5:  }

This is a simple interface that once a selection in our products web part list is made, we will send along with this interface the description of our product using the "ProductDescription" property.
Now to use this interface, we will implement it in our web part class, we need first to add a web part:
Right click the project node in the Solution Explorer -> Add -> New Item, from the Add New Item dialog, select "Web part" from the SharePoint Category, name the web part "ProductsList":



Three files are generated, open the "ProductsList.cs" file and add the following code:

   1:  public interface IProductDescription
   2:  {
   3:      // Our data is goes here
   4:      string ProductDescription { get; }
   5:  }
   6:   
   7:  [Guid("c9c9e1af-8b05-4ed7-92b7-63194e872f1f")]
   8:  public class ProductsList : 
   9:      System.Web.UI.WebControls.WebParts.WebPart,
  10:      IProductDescription
  11:  {
  12:      // Keep track of our product list selection
  13:      private int Selection { get; set; }
  14:   
  15:      // Holds the products description
  16:      private string[] ProductsDescription = 
  17:      { 
  18:          "This is a must see movie, I really got the idea years after",
  19:          "Nice mouse pad with a smily face of Homer Simpson",
  20:          "Very nice cup holder with USB heater"
  21:      };
  22:   
  23:      public ProductsList()
  24:      {
  25:          // Initialize our selection
  26:          Selection = -1;
  27:      }
  28:   
  29:      protected override void CreateChildControls()
  30:      {
  31:          base.CreateChildControls();
  32:   
  33:          // Our list is a simple Radio button list
  34:          RadioButtonList productsList = new RadioButtonList();
  35:   
  36:          productsList.Items.Add(new ListItem("Matrix I", "0"));
  37:          productsList.Items.Add(new ListItem("Acme Mouse Pad", "1"));
  38:          productsList.Items.Add(new ListItem("Acme Cup Holder", "2"));
  39:   
  40:          // Each time we have a selection, we will update,
  41:          // not great though, can be enhanced with AJAX,
  42:          // it is easier than you think, till next Walkthrough
  43:          productsList.AutoPostBack = true;
  44:   
  45:          // Hook our event for the list
  46:          productsList.SelectedIndexChanged += 
  47:              new EventHandler(productsList_SelectedIndexChanged);
  48:   
  49:          this.Controls.Add(productsList);
  50:      }
  51:   
  52:      void productsList_SelectedIndexChanged(object sender, EventArgs e)
  53:      {
  54:          Selection = (sender as RadioButtonList).SelectedIndex;
  55:      }
  56:   
  57:      // This is where the fun begins, note the method attribute
  58:      [ConnectionProvider("Product Description")]
  59:      public IProductDescription ConnectionInterface()
  60:      {
  61:          // our web part implemented this interface
  62:          // we can send any object that implement this interface
  63:          return this;
  64:      }
  65:   
  66:      // IProductDescription Members implementation
  67:      public string ProductDescription
  68:      {
  69:          get
  70:          {
  71:              if (Selection != -1)
  72:                  return ProductsDescription[Selection]; // return the product description
  73:              else
  74:                  return "Select a product"; // in case there is no selection
  75:          }
  76:      }
  77:  }

Several things need to be explained, we talked about the connection interface IProductDescription, but how it communicates or gets exposed by the WSS framework, note the method ConnectionInterface(), this method is decorated with the [ConnectionProvider] attribute, which means one thing to the framework, the web part exposes an outgoing connection, and since our web part implements this interface (and defines the one property it has, ProductDescription), we can return our web part instance.

The rest is the logic of our web part UI setup and event handling, when this web part is connected, each time the page updates, the web part will send the data or product description (based on selection) to the consuming web part, which brings me to the second part, writing the consuming web part, build the project and make sure all compiles.

To write the consuming web part, add another web part to the project as we did earlier with the first one, name the web part "ProductDescription", the rest is easy:

   1:  [Guid("97c76944-ca8c-4201-b128-48e08a7e6753")]
   2:  public class ProductDescription : System.Web.UI.WebControls.WebParts.WebPart
   3:  {
   4:      private IProductDescription productDescriptionProvider = null;
   5:      public ProductDescription()
   6:      {
   7:      }
   8:   
   9:      protected override void CreateChildControls()
  10:      {
  11:          base.CreateChildControls();
  12:   
  13:          Label label = new Label();
  14:          // Read the passed data through our interface
  15:          if (productDescriptionProvider != null)
  16:              label.Text = productDescriptionProvider.ProductDescription;
  17:          this.Controls.Add(label);
  18:      }
  19:   
  20:      [ConnectionConsumer("Product Description")]
  21:      public void GetInterface(IProductDescription providerInterface)
  22:      {
  23:          // Here we go, our data interface
  24:          productDescriptionProvider = providerInterface;
  25:      }
  26:  }

In this web part we have control that gets updated with the product description, the data is passed through the GetInterface() method, this time decorated with the [ConnectionConsumer] attribute, that tells the framework to send the outgoing interface (IProductDescription) to this method.
Build the solution and make sure it compiles.

Now before we go to the next step in our walkthrough, we need to test the web parts in a simple web part page, to do that we need to install them, right click the project node -> Properties, go to the Debug tab -> Start browser with Url should be set to the site collection the web parts will be deployed to, make sure to set it, mine is http://localhost/ by default. 

Save and open the WSP View (if not showing, go to View -> Other Windows -> WSP View), click on the Refresh button on the top of the view, nodes for the features that define the web parts will show, under each feature there is a feature.xml file, open it and in the tag, modify the Title attribute and add a Description attribute (Do the same for the other feature file under ProductsList):



These settings relates to the feature that will install the web parts, for the web parts titles, expand the web part category, for example ProductDescription under feature.xml in the previous figure, click on the ProductDescription.webpart and modify the properties element as follows (Do the same for the other web part):

   1:  <property name="Title" type="string">Products List</property>
   2:  <property name="Description" type="string">Displays list of products</property>

These are the title and description of the web part in the web part selection dialog.
Now click F5 to deploy and run IE, in the main page, I edited the home page to add web parts, the web parts will be in the "All Web Parts" -> "Miscellaneous" group:



Select the two web parts and click Add, next configure the connections, from Products List web part add a connection to Product Description web part:



Exit edit mode and select a product from the product list to see its description in the product description.

Thoughts: The page will always post back, we can use AJAX to enhance the user experience, but we need to configure the SharePoint site to use .NET 3.5 features, the trick is easy, you can open the web site from Visual Studio 2008 and configure it's settings to use 3.5 features.

In the next step (Step 2), I will show you how to create a document library instance, add a web part page to it.
[Download source code]


The problem with "_" in MOSS...not funny
2009-09-08T23:30:00.000-07:00
I setup a VM for SharePoint 2007 server for demo purposes, while I was preparing my demo on Form & Excel Services, I was unable to publish any, I just don't know why, I did everything right, I re-created the VM machine :( this time I am sure all is right, I have it worked before on many VM machines, so I decided (out of despair) to change the name of the machine.......and it worked!!!


This is not funny; my machine name was "dev_moss", yes!!! It was the "_" letter! Don’t know why, but it just won’t work if the machine name has "_" in it, this applies only to this case when you are setting up an isolated VM machine, I didn't try it with a real physicall machine, any how, hope they will fix it. The problem can be solved if the SharePoint site is published with a header from IIS, because it wont reference the machine name, and this is from other guys who faced the same problem,


Me, Jeeran and Team System 2008
2009-08-18T10:02:00.000-07:00

Early this week I finished my first consultation project for Jeeran, a web development company, the consultation was to setup Team Foundation Server 2008, show Jeeran the value of Team System (through walkthroughs and training sessions), utilize and customize SCRUM for team system to manage their development projects. It was really great experience; I enjoyed working with the project manager and Team Leaders.
At the end, I prepared a virtual machine with VSTS 2010 Beat 1, yep, this was as an added bonus to this consultancy, and I am sure that once released, Jeeran can have a good idea about it and can decide to upgrade if they want.



Agile, Tools and OOP
2009-08-11T00:46:00.001-07:00
In my last consultation to implement TFS 2008, the management asked me to find an easy and effective process to remove certain developed/implemented user stories from current project and prevent them from being released, they always face problem going back to code and start removing those features, which takes long time and sometimes needs further testing to make sure the modifications did not affect the product as whole.

The solution lies in three areas:

First, Your Process, the process already implemented is SCRUM, SCRUM is Agile, and in this process the client (or product owner) must be part of the whole process and with the help of the development team and subject matter experts, the product owner early in the project can select and rank the features that needs implementation.

Second, Tools like TFS can help make this less painful, features like branching, labeling and merging in TFS SCC can be used to build an effective deployment process based on the ability to selectively promoting feature, a process known as "promotion modeling", more on this:
http://thirdshelf.com/2008/09/24/source-code-promotion-model/http://www.ericsink.com/scm/source_control.html
This is good, but tools is useful as long as you plan properly and have a planned process to follow

Finally, OOP! This is important, if your developers follow AGILE coding practices (They are OOP, I should not even call them Agile) like SRP, SoC, IoC, OCP, LSP, etc... You can be sure that changing and adopting to change is easy or at least less painful process. Here is a good example on good process planning, include a code review process that always directs your programmers to use best practices in coding, do mentoring on using code written based on best practices, like Microsoft Enterprise Library for example, this way they will transparently implement others best practices, more on this:
http://mmiika.wordpress.com/oo-design-principles/


Nice SCRUM tutorial (10 minutes)
2009-08-11T00:42:00.000-07:00
This is a very illustrative and easy to follow tutorial on SCRUM under 10 minutes, really nice work, available on YouTube




TFS 2008 Consultation
2009-08-10T23:51:00.000-07:00

The last month was very interesting, I got the chance to do a consultation for a web development company with 45 developers, we installed, configured TFS 2008, customized the SCRUM process template, setup Web Access for Team System (TeamPlain), setup code review process, did a full training on the VSTS editions (Developer, Architect, Database and Test), and as added bonus, delivered a virtual machine with VSTS and TFS 2010 Beta 1.
Downloads	Title
Video \| No Code	Iteration -1: Intro to Agile
Video \| No Code	Iteration 0 - Part A: Organizing Requirements
Video \| No Code	Iteration 0 - Part B: Estimating Tasks and Setting up CI Server
Video \| Code	Iteration 1 - Part A: Using TDD to drive our first User Story
Video \| Code	Iteration 1 - Part B: Integrating with Rhino Tools and ASP.NET MVC frameworks
Video \| Code	Iteration 1 - Part C: Our First Controller and View in ASP.NET MVC
Video \| Code	Iteration 1 - Part D: Refactoring to Eliminate Technical Debt
Smart = new Smart(security);

Nessus Integration API for Happy .NET Developer

Agile

SharePoint 2010 Beta is here...

WCF - Windows Communication Foundation

SharePoint Walkthrough – Playing with features (Step 3)

SharePoint Walkthrough – Playing with features (Step 2)

SharePoint Walkthrough – Playing with features (Step 1)

The problem with "_" in MOSS...not funny

Me, Jeeran and Team System 2008

Agile, Tools and OOP

Nice SCRUM tutorial (10 minutes)

TFS 2008 Consultation

Smart `= new Smart(security);`
