UruIT - An offshore software development company from Uruguay

Extending ASP.NET Webparts: Cross-browser Drag and Drop functionality using JQuery

2009-08-19T15:11:00Z

One of the most interesting features in ASP.NET are WebParts. But one of the issues right now is the cross browser compatibility.

So with the default behavior you can add a WebpartZone and then drop your UserControl on it, but then even when you have a good usability experience using IE (you can drag & drop a WebPart to a different WebPartZone easily), as soon as you open it using Firefox or any other browser and activate the design mode of the page then you just lose this feature.

In order to achieve a cross browser experience in terms of drag and drop (which seems to be one of the most exciting feature when using webparts), I did some research and found nothing but some out-of-date workarounds to deal with this issue and partially.

So we decided to extend the WebPartZone class and add some JQuery capabilities in order to achieve the desired feature.

To solve the Drag & Drop problem of the WebParts we need three JQuery plugins.

UI Core
Draggable
Droppable

These plugins can be downloaded from http://www.jqueryui.com/download

The UI Core is required so the other two plugins can actually work.

Draggable plugin allows any element of the page to be dragged and droppable allows us to specify the areas were we can drop the selected element.

In order to add the drag behavior we need to add some code when the webpart is rendered. We can do this by extending the WebPartZone class.

In our example the page that inherits from WebPartZone is called ExtendedWebPartZone and it overrides the RenderBody method from the base class.

The following code can be used to extend the class:

        1:  

       2: protected bool IsDesignMode { get; set; }

       3: protected override void RenderBody(HtmlTextWriter writer)

       4: {

       5: if (this.WebPartManager.DisplayMode.Name == "Design")

       6: {

       7: this.IsDesignMode = true;

       8: }

       9: if (this != null)

{

if ((base.DesignMode

|| ((base.WebPartManager != null)

&& base.WebPartManager.DisplayMode.AllowPageDesign))

&& (((this.BorderColor != Color.Empty)

|| (this.BorderStyle != BorderStyle.NotSet))

|| (this.BorderWidth != Unit.Empty)))

{

Style style = new Style();

style.BorderColor = this.BorderColor;

style.BorderStyle = this.BorderStyle;

style.BorderWidth = this.BorderWidth;

style.AddAttributesToRender(writer, this);

}

writer.RenderBeginTag(HtmlTextWriterTag.Table);

WebPartChrome webPartChrome = this.WebPartChrome;

int index = 0;

//If there are no webparts in this WebPartZone then

//we render an empty droppable area

if (WebParts.Count == 0 && this.IsDesignMode)

{

this.RenderEmptyZoneBody(writer, index);

}

else

{

//Loop through all the webparts and render the droppable areas

//and add the draggable style to the webparts

foreach (WebPart wp in WebParts)

{

if (this.IsDesignMode && index == 0)

this.RenderDroppableRow(writer, index);

writer.RenderBeginTag(HtmlTextWriterTag.Tr);

writer.RenderBeginTag(HtmlTextWriterTag.Td);

if (this.IsDesignMode)

{

writer.AddStyleAttribute(HtmlTextWriterStyle.Position, "");

writer.AddAttribute(HtmlTextWriterAttribute.Class, "draggable");

writer.AddAttribute("webPartID", "WebPart_" + wp.ID);

writer.RenderBeginTag(HtmlTextWriterTag.Table);

}

else

writer.RenderBeginTag(HtmlTextWriterTag.Table);

writer.RenderBeginTag(HtmlTextWriterTag.Tr);

writer.RenderBeginTag(HtmlTextWriterTag.Td);

webPartChrome.RenderWebPart(writer, wp);

writer.RenderEndTag();

writer.RenderEndTag();

writer.RenderEndTag();

writer.RenderEndTag();

writer.RenderEndTag();

index++;

if (this.IsDesignMode)

this.RenderDroppableRow(writer, index);

}

}

writer.RenderEndTag();

}

}

//It renders a TableRow tag with the droppable attribute

private void RenderDroppableRow(HtmlTextWriter writer, int index)

{

writer.RenderBeginTag(HtmlTextWriterTag.Tr);

writer.AddAttribute(HtmlTextWriterAttribute.Class, "droppable");

writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "20px");

writer.AddAttribute("wpindex", index.ToString());

writer.RenderBeginTag(HtmlTextWriterTag.Td);

writer.RenderEndTag();

writer.RenderEndTag();

}

//This method creates the empty zone that allows webparts

//to be droped in

private void RenderEmptyZoneBody(HtmlTextWriter writer, int index)

{

string emptyZoneText = this.EmptyZoneText;

bool designMode = ((!base.DesignMode && this.AllowLayoutChange)

&& ((base.WebPartManager != null)

&& base.WebPartManager.DisplayMode.AllowPageDesign))

&& !string.IsNullOrEmpty(emptyZoneText);

//Depending on the orientation that the webpart has is how 

//we acctually render the empty zone

if (this.LayoutOrientation == Orientation.Vertical)

writer.RenderBeginTag(HtmlTextWriterTag.Tr);

if (designMode)

writer.AddAttribute(HtmlTextWriterAttribute.Valign, "top");

if (this.LayoutOrientation == Orientation.Horizontal)

writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");

else

writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");

writer.AddAttribute(HtmlTextWriterAttribute.Class, "droppable");

writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "20px");

writer.AddAttribute("wpindex", index.ToString());

writer.RenderBeginTag(HtmlTextWriterTag.Td);

if (designMode)

{

Style emptyZoneTextStyle = base.EmptyZoneTextStyle;

if (!emptyZoneTextStyle.IsEmpty)

emptyZoneTextStyle.AddAttributesToRender(writer, this);

writer.RenderBeginTag(HtmlTextWriterTag.Div);

writer.Write(emptyZoneText);

writer.RenderEndTag();

}

writer.RenderEndTag();

if (this.LayoutOrientation == Orientation.Vertical)

writer.RenderEndTag();

if (designMode && this.DragDropEnabled)

this.RenderDropCue(writer);

}

  

protected override void Render(System.Web.UI.HtmlTextWriter writer)

    {

        if (this.WebPartManager.DisplayMode.Name == "Design")

            this.IsDesignMode = true;

  

        if (this != null)

        {

            writer.AddAttribute(HtmlTextWriterAttribute.Id, this.ID);

            writer.AddAttribute(HtmlTextWriterAttribute.Class, "webPartZoneClass");

            writer.RenderBeginTag(HtmlTextWriterTag.Table);

            writer.RenderBeginTag(HtmlTextWriterTag.Tr);

            writer.RenderBeginTag(HtmlTextWriterTag.Td);

  

            this.RenderBody(writer);

  

            writer.RenderEndTag();

            writer.RenderEndTag();

            writer.RenderEndTag();

        }

        else

        {

            base.RenderContents(writer);

        }

    }

The RenderBody method it's called every time a WebPartZone is rendered. We then iterate through the WebPart list to check if the WebPartManager is in DesignMode. If this is the case we check if this is the first WebPart in the list. If so, we call the RenderDroppableRow in order to inject a TableRow into the HtmlTextWriter, to contain the droppable class and we set the attribute wpindex so we can use it at a later stage through our Jquery code to know where the webpart was dropped.

After that we need to check again the IsDesignMode flag, draw a table and set the CSS-class attribute to “draggable”. We also need to add the attribute webPartID so we can identify the webpart dropped and generate generate the correct postback in order to persist the changes.

Once we extended the class we need to modify the aspx page containing the WebParts.

First we need to add the references to the Jquery framework and the plugins.

Next we can define some CSS style so when the DesignMode is activated the droppable areas are highlighted and when we move a webpart over a droppable zone it get's colored.

       1:  

       2: <style type="text/css">

       3: #PartZone

       4: {

       5: border: dashed 1px #DDDDDD;

       6: }

       7: .ui-state-hover

       8: {

       9: background-color: red;

      10: }

      11: .ui-state-active

      12: {

      13: border: dashed 1px red;

      14: }

      15: </style>

Finally we need to write some JQuery code:

       1:  

       2: <script type="text/javascript">

       3: $(document).ready(function() {

       4: //Here we set the parameters for the draggable webparts

       5: //(I.E: 

       6: $(".draggable").draggable({

       7: revert: 'invalid',

       8: zIndex: 1000

       9: });

$(".droppable").droppable({

tolerance: 'touch',

activate: function(event, ui) {

$(".droppable").addClass("ui-state-active");

var parentTr = ui.draggable.parents("tr").eq(0);

var prevDroppable = parentTr.prev().find(".droppable");

var nextDroppable = parentTr.next().find(".droppable");

prevDroppable.droppable('disable');

nextDroppable.droppable('disable');

prevDroppable.removeClass("ui-state-active");

nextDroppable.removeClass("ui-state-active");

},

drop: function(event, ui) {

var webPartZoneId = "ctl00:ContentPlaceHolder1:" + 

$(this).parents(".webPartZoneClass").attr("ID");

var index = $(this).attr("wpindex");

var webPartId = ui.draggable.eq(0).attr("webPartID");

__doPostBack(webPartZoneId, 'Drag:' + webPartId + ':' + index);

},

deactivate: function(event, ui) {

$(".droppable").droppable('enable');

$(".droppable").removeClass("ui-state-active");

},

over: function(event, ui) {

$(this).removeClass("ui-state-active");

$(this).addClass("ui-state-hover");

},

out: function(event, ui) {

$(this).removeClass("ui-state-hover");

$(this).addClass("ui-state-active");

}

});

});

</script>

Basically all this code is generic except when we create the variable webPartZoneId used to get something like this "ctl00:ContentPlaceHolder1:".

However we needed this because we are using a MasterPage, so prefix are needed for every control. This can be added dynamically.

The final step after you add the WebPartManager to the page is register the Assembly of the project that contains the ExtendedWebPartZone. For instance:

       1:  

       2: <%@ Register Assembly="UruIT.Web.UI.CustomWebPart" 

       3: Namespace="UruIT.Web.UI.CustomWebPart"

       4: TagPrefix="cc1" %>

We are now ready to add our webparts to the page! You can use some code similar to this one:

       1:  

       2: <table style="width: 100%;">

       3: <tr>

       4: <td>

       5: <cc1:ExtendedWebPartZone ID="LeftWebpartZone" runat="server" Width="100%" 

       6: BorderWidth="1px" MenuPopupStyle-BackColor="#E5EEFD" 

       7: MenuPopupStyle-Font-Size="10px">

       8: <ZoneTemplate>

       9: <uc2:Webpart1 ID="Webpart11" runat="server" />

      10: </ZoneTemplate>

      11: </cc1:ExtendedWebPartZone>

      12: </td>

      13: <td>

      14: <cc1:ExtendedWebPartZone ID="RightWebpartZone" runat="server" 

      15: Width="100%" BorderWidth="1px" MenuPopupStyle-BackColor="#E5EEFD" 

      16: MenuPopupStyle-Font-Size="10px">

      17: <ZoneTemplate>

      18: <uc3:Webpart2 ID="Webpart21" runat="server" />

      19: </ZoneTemplate>

      20: </cc1:ExtendedWebPartZone>

      21: </td>

      22: </tr>

      23: </table>

And this is how the drag and drop will look like in both Firefox and IE:

You could use the same idea to add more functionality to the webpart such a custom menu or any other cool visual behavior without needing a postback.

I’m planning to improve this code to get a more generic and reusable control. I’ll post it as soon as I’m done with it, but in the meantime this post can help anyone dealing with similar issues.

Post written by Sebastian Rodriguez – .NET Web Developer at UruIT - a Nearshore .NET Software Company

Interoperability between MFC/WIN32 and WPF

2009-07-14T17:40:00Z

C++/CLI extends C++ allowing the usage of .NET managed code and offer a new and more transparent way to interop managed and native worlds.

Let’s create a simple MFC application showing an example how to listen to events raised from a WPF object embedded on it, and then react to them within the MFC application.

Open Visual Studio 2008 and create a new MFC application project. I’m naming it “MFCWPFEventsInterop”.

The MFC wizard will be displayed.

The only change needed is to set the project style to Office as it is shown in the following picture and click Finish button.

Now we have to change project settings in order to use C++/CLI. Enter project properties and change to Common Language Runtime Support (/clr) and then apply your changes.

We also need to reference the WPF assemblies in Common Properties tab.

Then open the “MFCWPFEventsInterop.h” file and add the declaration of OnFileNew method as it is shown in the following code:

        1:  

       2: class CMFCWPFEventsInteropApp : public CWinAppEx

       3: {

       4: public:

       5: CMFCWPFEventsInteropApp();

       6: // Overrides

       7: public:

       8: virtual BOOL InitInstance();

       9: // Implementation

      10: UINT m_nAppLook;

      11: BOOL m_bHiColorIcons;

      12: virtual void PreLoadState();

      13: virtual void LoadCustomState();

      14: virtual void SaveCustomState();

      15: afx_msg void OnAppAbout();

      16: afx_msg void OnFileNew();

      17: DECLARE_MESSAGE_MAP()

      18: };

Then open “MFCWPFEventsInterop.cpp” file, add the two “using” sentences as shown below, and also modify the “ON_COMMAND” so it will use our own implementation of the OnFileNew method.

       1:  

       2: // MFCWPFEventsInterop.cpp : Defines the class behaviors for the application.

       3: //

       4: #include "stdafx.h"

       5: #include "afxwinappex.h"

       6: #include "MFCWPFEventsInterop.h"

       7: #include "MainFrm.h"

       8: #include "ChildFrm.h"

       9: #include "MFCWPFEventsInteropDoc.h"

#include "MFCWPFEventsInteropView.h"

using namespace System;

using namespace System::Windows;

#ifdef _DEBUG

#define new DEBUG_NEW

#endif

// CMFCWPFEventsInteropApp

BEGIN_MESSAGE_MAP(CMFCWPFEventsInteropApp, CWinAppEx)

ON_COMMAND(ID_APP_ABOUT, &CMFCWPFEventsInteropApp::OnAppAbout)

// Standard file based document commands

ON_COMMAND(ID_FILE_NEW, OnFileNew)

ON_COMMAND(ID_FILE_OPEN, &CWinAppEx::OnFileOpen)

// Standard print setup command

ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinAppEx::OnFilePrintSetup)

END_MESSAGE_MAP()

Finally we need to add our implementation code at the end of the file as 

follows:

// CMFCWPFEventsInteropApp message handlers

void OnWPFAppClosed(Object ^sender, EventArgs ^args)

{

AfxGetApp()->m_pMainWnd->SendMessage(WM_CLOSE);

}

void CMFCWPFEventsInteropApp::OnFileNew()

{

CWinAppEx::OnFileNew();

Window^ wpfWindow = gcnew Window();

wpfWindow->Title = "This is a WPF window";

wpfWindow->Closed += gcnew EventHandler(OnWPFAppClosed);

wpfWindow->Show();

}

As you cannotice in the code, we are creating and showing a WPF window at runtime when we add a new file on the MFC application.

We are also subscribing to the Closed event of the WPF window and in the event handler we are executing some native C++ code, in this case forcing the application to close.

When you debug the application you will see something similar to the picture below and the if you click the close button within the WPF object, the entire application will shutdown.

This is a simple example on how you can handle WPF window events (or any event) within a MFC or WIN32 application. You can extend it to handle any event thrown from your WPF application and react to it within the native code, so you can have the best of both native and managed worlds.

This post was written by Marcelo Martinez – Lead WPF Developer @ UruIT

Validating Stored Procedures using SQL Server 2008 policies and C#

2009-07-03T21:25:00Z

Microsoft SQL Server 2008 incorporates a new feature named Policy Based Management, allowing the administration of SQL 2008-based policies. DBAs can control many different aspects of SQL Server and automate several time-consuming tasks.

Among other uses, the policies can help to ensure that Stored Procedures follow a desired standard (set of policies).

Then you could also write your own application to validate a set of stored procedures against the different policies defined in the target server, using .NET code and a set of classes available to interact with SQL Server objects.

Additionally, you could validate stored procedures from previous SQL versions such as 2005 and 2000.

In order to write some .NET code to achieve this, first we have to refer to a few assemblies:

          1: using Microsoft.SqlServer.Management.Dmf;

         2:  

         3: using System.Data.SqlClient;

         4:  

         5: using Microsoft.SqlServer.Management.Sdk.Sfc;

         6:  

         7: using Microsoft.SqlServer.Management.Smo;

Then we should get the policies collection from our target server. We will use the GetPolicyCollection method which receives a parameter with the connection string information from our SQL Server 2008 hosting the policies.

       1: private PolicyCollection GetPolicyCollection(string ConnectionString)

       2:  

       3: {

       4:  

       5: PolicyStore policyStore = new PolicyStore();

       6:  

       7: SqlConnection oSqlConn = new SqlConnection(ConnectionString);

       8:  

       9: SqlStoreConnection oStoreConn = new SqlStoreConnection(oSqlConn);

      10:  

      11: policyStore.SqlStoreConnection = oStoreConn;

      12:  

      13: return policyStore.Policies;

      14:  

      15: }

Then we can write some code to ensure that our StoredProcedure complies with established policies.

This method receives a StoredProcedure object, which represents the stored procedure we will evaluate.

Policy class exposes some methods to validate an StoredProcedure objects agains it.

We will iterate through the collection of policies and invoke the Evaluate method passing the sp object as parameters, and telling the framework to check whether the validation fails or not, using the AdHocPolicyEvaluationMode enum (in this case will be set to Check), and an array with the objects to validate.

       1: private bool Validate(StoredProcedure sp)

       2:  

       3: {

       4:  

       5: Object[] parameters = new Object[1];

       6:  

       7: parameters[0] = sp;

       8:  

       9: PolicyCollection policyCollection = GetPolicyCollection(strConnectionString);

      10:  

      11: foreach (Policy policyItem in policyCollection)

      12:  

      13: {

      14:  

      15: if (policyItem.Evaluate(AdHocPolicyEvaluationMode.Check, parameters))

      16:  

      17: {

      18:  

      19: return true;

      20:  

      21: }

      22:  

      23: return false;

      24:  

      25: }

      26:  

      27: }

And that’s it! You can have a friendly UI to display how a set of stored procedures will comply or not with the defined policies at the target server, before you actually decide to move them.

(by the way, it’s quite easy to move stored procedures from one server to another using the classes included in these libraries and a few lines of .NET code).

Post written by Santiago Gonnet - .NET Developer @ UruIT

How to set up a VPN with ISA Server 2006 and NPS in Windows 2008 Server – Step by Step

2009-06-12T19:51:29Z

We all know the advantages of having a Virtual Private Network in a company. This implies that consultants can connect to the internal network and even to their own desktop machines while they are working at client offices (even in another country). ISA Server makes this task pretty simple.

One of the most challenging problems is how to authenticate users if your ISA Server is not a domain member. In this post we will explain how to solve this problem, using ISA Server 2006 (installed on Windows 2003 Server) and a Network Policy Server (NPS, installed on Windows 2008 Server) acting as a RADIUS server.

Network Policy Server in Windows 2008 is the replacement for the Internet Authentication Service. I will show you here how to install NPS as well.

In this post, I will guide you through the steps needed to configure our own VPN.

Before starting to configure the VPN, we will set up the NPS server, which will authenticate the VPN clients.

Setting up NPS

The Network Policy Server is only available for Windows 2008 Server, so it will not be in the same system with the ISA Server. It must be a domain member, or be in the domain controller.

The idea of having a RADIUS server is to allow the ISA Server to authenticate the users, through Active Directory. The problem is that the ISA Server is not a domain member, so it can’t connect directly to the AD. So, the RADIUS server acts as a bridge between ISA and AD.

Installation

To install NPS, you must give the server the “Network Policy and Remote Access” role. To do this, click “Add roles” in the “Server Manager”.

Then, select the role from the list as shown in the following picture.

In the next step, select “Network Policy Server”, and click “Next”.

Configuration

As the NPS documentation says: “NPS performs authentication by comparing user credentials that it receives from network access servers with the credentials that are stored for the user account in Active Directory Domain Services (AD DS). In addition, NPS authorizes connection requests by using network policy and by checking user account dial-in properties in AD DS.”

Therefore, in order to allow NPS to access user information on AD, it must be registered in AD. This mean the NPS server belong to the “RAS and IAS Servers” AD group.

This is accomplished from the NPS Console. To launch it, go to Administrative tools. There you will see the NPS icon. From the left tree-view, select the root, and select Action à Register service in Active Directory.

Registering a RADIUS client

In order to allow the ISA Server to make requests to the NPS, ISA must be added as a client to the NPS. To do this, expand the root in the left pane tree-view, right click “RADIUS Clients” and then click on “New RADIUS client”.

Once the dialog is displayed, complete the ISA Server information. Give it a friendly name, followed by the NetBIOS name or internal IP. Ensure that the NetBIOS name is resolved to the internal network interface.

After that, select Microsoft as the Vendor.

You will also need a long password to encrypt messages to and from the ISA. You will need to type this very same password later, when we configure the ISA.

Finally, check the “Access-Request messages must contain the Message-Authenticator attribute”.

As you will see later, it is recommended to create an Active Directory group which will have permissions to use the VPN. This will allow you to easily assign permissions to the users, just making them members of that group.

Creating Network Policies

You must configure NPS to allow VPN connections. This is done creating a new network policy (formerly known in IAS as remote access policies).

To create the rule, follow these steps:

1. Open the NPS console

2. On the left tree-view, expand the Policies node

3. Right click “Network Policies”, and click on “New”

4. Type the rule name, something like “VPN Users Authentication”

5. On “Type of network access server” select “Remote Access Server (VPN-Dial In)”

6. Click add to specify a condition

7. We want to authenticate all the users that belong to the “VPN Users” group (previously created), so we need to select “User Groups”. Click “Add”.

8. Specify the group name and click “Ok”.

9. Click “Next”.

10. On the “Specify Access Permission” select “Access Granted”.

11. On the “Configure Authentication Methods”, click “Add” and select “EAP-MSCHAP v2” as shown in the following picture. Click “Next”.

12. You are now able to configure constraints, such as date and time restrictions, idle time and more. For the sake of keeping this post simple, we will not create any restrictions.

13. On the configure settings screen, click “Next”.

14. Review the configuration, and click “Finish”.

The RADIUS server is now ready to be used by the ISA Server. Keep reading to get the ISA set up properly.

Configuring the VPN

To create a VPN, first of all we must enable it on the ISA Server. To do this, open the Management Console, select then VPN node on the left-hand tree. Then, click “Enable VPN Client Access”.

This action will enable a network rule, which authorizes all the outbound traffic, from the VPN network to the internal network. You can edit this rule to suit your needs.

To see this rule, click on “Networks” on the left-hand tree.

IP address assignment

When the remote users connect to the VPN, they will need an IP. There are two ways to solve this.

1. Use a DHCP server.

2. Use the ISA Server Address Pool.

You must determine which solution is better for your company. We will use the ISA Server Address Pool.

To configure it, from the left pane, expand the ISA Server in the tree-view, and then click on the Virtual Private Network node. Now, in the Tasks pane (on the right) click on “Configure address assignment”.

The following dialog will appear:

Click the “Add” button. Add the IP range for the VPN clients.

Configuring Authentication

As you already know, we are going to use the previously set up RADIUS server to authenticate the users. We have to tell ISA where the RADIUS server is.

1. Open the ISA Server Management Console and select VPN on the left-hand tree-view.

2. On the “Tasks” pane on the right, click on “Specify RADIUS configuration”. The following screen will show up.

3. Check the “Use RADIUS for authentication”.

4. Press the “RADIUS Servers…” button.

5. Click “Add” to insert a new server. Specify the IP Address and a description for the server. Ensure that you are using the internal network interface.

6. Click the “Change” button to specify the shared key. You must enter here the same key created when configuring the NPS server. If you make a mistake here, users will fail to authenticate.

7. Finally, check the “Always Use Message Authenticator”. Click “OK”.

8. Apply the configuration.

Enable VPN Access

On last step is required, so that the ISA Server will support VPN connections. Click Virtual Private Networks from the Scope pane (on the left).

On the right-hand pane click on “Configure VPN Client Access”. Check “Enable VPN client access” as shown in the picture below.

When you enable VPN client access, the Routing and Remote Access Server (RRAS) service is started, and is set to start automatically. To check the service status, click “Monitor” on the left pane, and then select the “Services” tab.

On the protocols tab on the same screen, verify that the “Enable PPTP” is checked.

That’s it! You have now a VPN configured, in a non domain member server, authenticating domain users, through NPS.

Considerations

When the user connects to the VPN, the default gateway is overridden, so that all the traffic goes through the ISA Server. This is a security setting. If you are interested in create custom routes (other than manually) you could use Connection Manager and the Administration Kit.

If you require some extra security on the connection, you should take a look at the L2TP protocol which uses IPSec.

Post written by Matias Delgado – Infrastructure and Development Tools Lead @ UruIT

How to avoid copying a blank line in Visual Studio

2009-03-17T19:50:00Z

Many times I find myself copying some piece of code, then positioning in a blank line where I want to paste it, and then mistakenly pressing Ctrl+C again instead of Ctrl+V. This copies a blank line to the clipboard overwriting what I had originally copied, so when I finally manage to paste it, it is not what I wanted.

It was a great surprise to discover that this behavior is configurable in Visual Studio:

Just go to Tools/Options/Text Editor/All Languages, and uncheck the box where it says “Apply Cut or Copy commands to blank lines when there is no selection”.

Thanks Scott Cate for a great source of Visual Studio tricks !!

Writing custom rules for TFS 2008 Code Analysis check-in policy

2009-03-17T18:52:00Z

Recently I was involved in a project for a bank which has a software factory that manages hundreds of applications, developed internally or by third-parties. One of the things they needed was to enforce that every code that's checked-in to the repository followed the bank's guidelines, which involve coding standards, best practices, etc.

We found that Team Foundation Server's check-in policies can be an excellent solution for this kind of scenario. One of the policies TFS ships with out of the box is the "Code Analysis Check-In policy", which runs your Code Analysis rules every time someone attempts to check-in code. If the rules fail, the check-in does not succeed. (For those of you that haven't heard of Code Analysis, it is basically FxCop integrated into Visual Studio, version 2005 onwards).

So one of the things we had to do to enforce the bank's guidelines was to develop the rules not already covered by FxCop/Code Analysis. It turns out that this is a relatively easy task with FxCop 1.36, which provides a new API called Introspection to perform the code analysis. If you have developed custom rules for prior versions of FxCop using Reflection, you will find the new API much more powerful and easy to use.

Jason Kresowaty's guide on writing custom fxcop rules is a great place to start learning the subject, and he has also developed a great tool for aiding in the use of Introspection.

One important detail is that FxCop works against compiled Intermediate Language. This means that a huge advantage is that the rules are not dependant on the language of your code, as long that it targets the .NET Framework. On the other side, a disadvantage is that many aspects of your code are not included in the IL so you can't check against them, i.e. positioning of curly braces, parenthesis, etc. For this kind of rules we had to use other tools, like StyleCop, which I will cover in another post.

Enough for the introduction, let's go to the coding and create a simple rule: "Enum's names should not end with 'Enum'". The steps involved to implement such a rule are:

Create a new C# class library project and add references to Microsoft.FxCop.Sdk.dll and Microsoft.CCi.dll. Both come with FxCop.

Add an xml file, which will contain the description about your rules; the name of the file is not important. This information will be used by FxCop/Code Analysis to show your rule on the UI. It will have the following structure:

Most of the information here is pretty self-explanatory, with exception of the Resolution field, wich I will cover later.

Add a class to your project, and make it inherit from BaseIntrospectionRule. You should add a parameterless contstructor to your class, but that calls a base constructor and provides three parameters:

Name: name of the rule, must match the TypeName specified in the rule metadata XML.
Xml config: the name of the metadata XML resource. It is the name of the assembly plus the name of the xml created on step 2 but without the extension.
Xml assembly: the assembly containing the metadata XML resource.

Override the method check, and do the magic here.

When the analysis is run, this method gets called by the runtime every time a type is found (such as a class, delegate, enum, struct or interface). If you are interested in checking other elements, such as methods, there are other overloads of the Check method that you can override.

As we are only interested in Enums here, we cast the TypeNode received to an EnumType to see if we are dealing with one. In case we are, then we just have to check the type's name to see if it has the incorrect suffix.

When a rule violation is found, we must add a Problem to the Problem collection inherited from the base rule class. We must supply a Resolution object to the problem constructor. This object just builds the description that will be shown to the developer about how to fix the rule violation. Remember that in the config xml we supplied the description and placed a positional placeholder such as the one's used in String.Format?

Well, in the Resolution constructor we are supplying the parameters to fill the placeholders, in our rule we are passing-in the Enum's name.

Multiple resolutions can be defined which are assigned with a Name attribute in the xml and then accessed by code with the this.GetResolutionByName() method.

The last step is to build the assembly and copy it to c:\Program Files\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop\Rules. In case that you are using FxCop standalone exe, copy the dll to C:\Program Files\Microsoft FxCop 1.36\Rules.

And that's it. Open the tool (Visual Studio Code Analysis or FxCop), and you will see your newly defined rule.

Write some code that breaks it, and you will see your rule in action.

Hope you have found this post useful to get started writing custom FxCop rules. In future posts I will talk about other things that I have learned about this subject.

Post written by Manuel Babuglia, Senior Developer @ UruIT, a Nearshore Software Outsourcing Company from Uruguay

Boost Productivity Using DynamicData - how to add to an existing asp.net application

2008-12-19T13:00:00Z

It is hard for a customer to trust a software development company located in the other side of the globe (even when it is a nearshore one like our company), so some customers request some proof of concept before investing in a long term and expensive project.

Thanks to DynamicData, we can go beyond our customer requests and improve these small prototypes with almost no development effort.

DynamicData enables the creation of data driven web pages during runtime, with almost no code required.

In this post we will describe how to add pages (in this case administration pages for some of our prototype model objects), to an existing ASP.NET 3.5 application. It means that we first developed the prototype using basically ASP.NET 3.5, WF, Linq and EntityFramework, themes and master pages, among others, and then a few hours before delivering it, we improved the demo through adding some more links in the existing menu (using sitemaps), with new customized pages for users, roles, workflow steps and other entities administration. As we were using Enumerations for some handling a few object members, we also describe how to extend DynamicData to support them.

Let's summarize the steps we followed:

Step 1: Create a dummy DynamicData Web Application project.

This one is not mandatory but if you do it, you will have the folder structure and some keys added to the config required for DynamicData to work.

By default DynamicData directory is created where stands Page Templates and Fields Templates.

Copy this folder into PresentationLayer web application.

Next, change copied files namespaces to match the PresentationLayer namespace and change Page Templates master page to be "MasterPage.master".

Step 2: Register the data model and url routes.

We must specify DynamicData the data model to use. For this, first add a reference to BusinessEntities in PresentationLayer project. Then at Global.asax add the next code to register data model and routing, we are going to register DbDataContext created in BusinessEnities project:

public static void RegisterRoutes(RouteCollection routes)

{

MetaModel model = new MetaModel();

model.RegisterContext(typeof(DbDataContext), new ContextConfiguration() { ScaffoldAllTables = true });

routes.Add(new DynamicDataRoute("{table}/{action}.aspx")

{

Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),

Model = model

});

}

void Application_Start(object sender, EventArgs e)

{

RegisterRoutes(RouteTable.Routes);

}

Step 3: Add references to DynamicData assemblies.

To enable DynamicData we must add the following references to PresentationLayer project:

System.ComponentModel.DataAnnotations
System.Web.Abstractions
System.Web.DynamicData
System.Web.Routing

In the compilation section in the web.config add the following assemblies:

In the pages-controls section add the following tag prefix:

To enable ASP.NET new routing feature:

In the httpModules section add the following

In the System.WebServer - modules add the following

Creating new field template for Enum types.

Something that we faced when adapting our asp.net solution was that there is no template for Enum types, so columns like Roles, Status and Actions won't show.

This is how we fixed it:

First, we create the ascx template file for Enum types. Right click FieldTemplates - Add new Item and select Dynamic Data Field, name it "Enumeration".

Notice that two ascx templates are created: one for display "Enumeration.ascx" and other for edition "Enumeration_Edit.ascx".

Change Enumeration_Edit template source to be:

<%@ Control Language="C#" CodeBehind="Enumeration_Edit.ascx.cs" Inherits="UruIT.BalanceSheetModule.PresentationLayer.DynamicData.FieldTemplates.Enumeration_EditField" %>

<asp:DropDownList runat="server" ID="DropDownList1" CssClass="droplist" OnDataBound="DropDownList1_DataBound">

</asp:DropDownList>

Change Enumeration_Edit template code behind to be:

protected void Page_Load(object sender, EventArgs e)

{}

protected override void OnDataBinding(EventArgs e)

{

// When overriding OnDataBinding be sure to call the base class's

// OnDataBinding method so that registered delegates receive the event.

base.OnDataBinding(e);

// get a data bindable list of permissions for the DDL

var enumList = Enum.GetValues(Column.ColumnType);

DropDownList1.DataSource = enumList;

DropDownList1.DataBind();

}

protected override void ExtractValues(System.Collections.Specialized.IOrderedDictionary dictionary)

{

dictionary[Column.Name] = ConvertEditedValue(DropDownList1.SelectedValue);

}

protected void DropDownList1_DataBound(object sender, EventArgs e)

{

// make sure we are in edit mode

if (Mode == DataBoundControlMode.Edit)

{

// try to get an item in the list that matched the FieldValueString

ListItem item = DropDownList1.Items.FindByValue(FieldValueString);

if (item != null)

{

// if we get the value set the drop down list to FieldValueString

DropDownList1.SelectedValue = FieldValueString;

}

// This is one of those needed things I think it allows

// access to the actual control through Controls property

public override Control DataControl

{

get

{

return DropDownList1;

}

Step 5: Map Enum type columns to the correct template.

Once the template field for Enum types is created, we must map the columns of type Enum to the correct template.

For this, open "db.designer.cs" on BusinessEntities project. As an example search for BalanceSheet partial class and under status property add the following attribute:

[UIHint("Enumeration")]

It should look like this:

[Column(Storage="_Status", DbType="Int NOT NULL", CanBeNull=false)]

[UIHint("Enumeration")]

public Status Status

{

get

{

return this._Status;

}

set

{

if ((this._Status != value))

{

this.OnStatusChanging(value);

this.SendPropertyChanging();

this._Status = value;

this.SendPropertyChanged("Status");

this.OnStatusChanged();

}

Do this for all Enum type properties.

Step 5: Generate links to the new pages for administration.

Open "MasterPage.master" and under links add the following:

<tr>

<a href="http://weblogs.asp.net/Users/List.aspx">Users</a>

</td>

</tr>

<tr>

<a href="http://weblogs.asp.net/Companies/List.aspx">Company</a>

</td>

</tr>

<tr>

<a href="http://weblogs.asp.net/BalanceSheetFormats/List.aspx">Balance Sheets Formats</a>

</td>

</tr>

<tr>

<a href="http://weblogs.asp.net/BalanceSheetItems/List.aspx">Balance Sheets Items</a>

</td>

</tr>

Notice how the links matches the routes defined in "Global.asax" ({table}/{action}.aspx). We can change the List.aspx for any of this views: Details, Edit, Insert, ListDetails (all defined in PageTemplates directory).

We get the following result:

List View:

Details / Add View:

Notice how Role which is an Enum displays now as a DropDownList. This has been specified in the Enumeration_Edit.ascx.

Edit View

So in a nutshell we have created admin pages for some of our entities, with almost no code. We also extended it to allow Enumerations in the edit pages.

So DynamicData really boosted the development in this small project!

Post written by: Esteban Freyre. .NET developer @ UruIT

How to configure Project Server 2007 for Timesheets Management – A Complete Guide!

2008-10-23T11:30:00Z

Our main service is providing nearshore outsourcing to customers around the globe. It is very important for us to track effort spent as much detailed as possible, and report it to our customers, usually on a weekly basis.

After trying with other tools and not being 100% satisfied, we decided to take advantage of Microsoft tools and start using Project Server 2007 for time management here in our company.

I spent some hours doing research about this topic, and I found different articles and posts explaining just one chapter at a time, without finding a complete guide to install and configure this tool for this particular goal.

Even after we followed all the steps found around several sources, we were still not able to generate the reports with the time spent by the resources selected for this pilot, due to some issues with the browser and also with the Cube (Project integrates with Analysis Services) used for populating the data.

Then after several hours of effort with one of our Senior developers, we had our Project Server running and some of our team members were able to enter their timesheets using Project Web Access, a web interface exposed by this technology.

Using Project Server also enabled us to integrate Sharepoint workspaces for centralizing project documentation, risks, issues and tasks, with project schedule, costs and time management that we can also publish through web so our customers can have a snapshot of the project anytime. We can generate customized reports through Pivot Tables and Analysis Services integration.

Having this said, this is a powerful tool with a complete set of features, ideal for small, medium or enterprise organizations. Some features such as the web interface are really helpful for our nearshore software development practice, enabling both customers and remote teams to access the data everywhere.

These are the steps you should follow in order to install and configure Project Server 2007 for timesheet management:

1. Install Sharepoint Server 2007 in a brand new Virtual Machine with Windows Server 2003.

Step by step and different deployment scenarios can be found here: http://technet.microsoft.com/en-us/library/cc197758.aspx#section2

2. After installed, the project web access is located in a url like http://servername:port/PWA

3. Add a few domain users to the Project Server using the Server Settings / Security / Manage Users link.

4. Add your team members into Project Server resources list, using the Resources Center. These will be the team members you will allocate to each project and task.

5. Even when you can do almost everything from the Project Server web interface, it is faster to use your desktop version of Office Project 2007 to create projects, tasks and allocate resources. This requires the PM to have MS Office Project 2007 Professional version installed (Standard doesn´t support it)

6. To connect your Office Project to the Project Server 2007, you need to configure it through the Enterprise Options under the Tools menu.

7. Create a test project using the Project Center link / Add Project.

8. After adding a few test tasks, you must assign the team to the project and each task. This will allow the team members to see the assigned tasks and

a. Go to Build Team From Enterprise

b. Select the task(s)

c. Go to Assign Resources

d. Select the resources you want to assign. You can set costs and effort allocated.

9. Project Server requires timesheets periods to be defined (in most of the cases these will be mapped to each week of the year). You should go through each link in the Timesheets section under the Server Settings section.

There is a complete ebook for this topic which you should download and read from here http://technet.microsoft.com/en-us/library/cc197478.aspx

10. Once the timesheets periods have been defined, your team member should be able to view the assigned tasks after login into the PWA with his credentials.

11. Each resource will be responsible for creating the timesheet and reporting it. The timesheet can be populated with the assigned tasks, or can be blank and then populated using the Add New Line link

12. Resource should submit his timesheet. These will be usually automatically approved unless you configure it. The timesheet cannot be updated except for the admin, once it is submitted.

Once all of this is done, the database will have the data but you won´t be able to retrieve it using the reports yet.

First, you need to configure this feature, otherwise you will see just a blank page when clicking the Data Analysis link

In order to configure the Reports follow these steps:

1. Go to Create Server Settings, Views, New View, and select Data Analysis as the view type

2. Select your Data Analysis Services. If is it not populated you should go to check if Analysis Services was installed and all services are running.

3. Configure the settings and the data view properties (just follow the sections in the screen)

4. Configure the fields you want to display in the default timesheet view

5. Add the project server URL to the list of Local Intranet sites in your browser settings.

6. Configure your browser settings to allow ActiveX.

7. Configure your browser settings to allow Data Sources across domains.

And that´s all!

So if you follow these steps then you will be able to take advantage of Project Server reporting features:

I hope this guide is useful and ping us if you face any issues when using this powerful tool !

So far we are really satisfied with it.

Post written by - Marcelo Lopez, Project Manager @ UruIT Global IT Services

Dealing with SharePoint 2003 API and ASP.NET …

2008-08-07T15:42:00Z

If you have worked with SharePoint 2003 Webservices, then you probably had to deal with some security, permissions or impersonation issues. Some of these issues can arise if you don’t think in a solid architecture from scratch.

I will try to show a few recipes in order to make your life easier at the time of developing an ASP.NET web application integrated with SharePoint.

Let me introduce you to our project scenario. One of our customers in the public sector needed a solution which consisted in the following three main components: ASP.NET 2.0, Windows SharePoint Server and K2 Workflow engine (old technologies but these were non functional requirements from the customer).

The solution, currently deployed in the customer’s intranet supports the creation and flow of multiple documents within the organization based in well defined processes.

Both the ASP.NET application and the SharePoint Server run in the same box. The K2 Workflow Server runs in another box, both of them under the same Active Directory domain. Users get logged into the application by using Windows Authentication. Part of the application’s logic includes the creation of sub-sites and document’s uploading within several document libraries in SharePoint, with some code running in the ASP.NET application.Unfortunately, SharePoint 2003 does not support the creation of sub-sites through its Web Services, so we had no choice but to use the SharePoint API directly from our solution. This will end in chaos if we don’t face this correctly.Based in the previous scenario, the ASP.NET application is configured in IIS for using Windows Authentication with anonymous access unchecked.

This is because we need to know which user started a given process … in addition, K2 Workflow methods need to execute under the context of the logged user.

For achieving this, all that we needed to do is enable impersonation in the web.config. In consequence, every method in our ASP.NET application will run under the logged user’s credentials.

This is good for K2, but not a good option for SharePoint because not every user should be allowed to create sub-sites in our server.

What decided to use WindowsImpersonationContext for passing the credentials of a user with sufficient permission for creating sub-sites and managing document libraries in SharePoint.

In order to achieve this, we called the unmanaged LogonUser method for getting the appropriate token handle and after that creating a brand new WindowsIdentity object.

It is worth to emphasize that the code running inside the WindowsImpersonationContext will have elevated privileges – or not – but in our context it does, so we need to ensure that if something happens inside this code block we can revert to the original credentials:// Some work to do ... WindowsImpersonationContext impersonatedUser = null;

try

{

impersonatedUser = newIdentity.Impersonate(); // Elevated privileges work ...

} finally {

impersonatedUser.Undo();

}

// Some more work to do ...

At a first glance, it seemed everything was fine.But I recall exactly the time when we built the application, run it, debugged the code and got the impersonated user’s credentials properly, but as soon we call the CreateSite() method, a new exception had been thrown from Sharepoint: “Access is denied exception from hresult 0x80070005”

Not a descriptive one thought J … so what was going on?

We were trying to create the sub-site with the appropriate credentials but that wasn’t enough.

We forgot about something … the Application Pool identity!By default, IIS Application Pools run under the Network Service account.

This account has very few privileges in order to accomplish the least privilege execution principle.

We had to change this in order to let our SharePoint API methods run properly. The following is a very basic example of a web method which creates a sub site:

[WebMethod] public void CreateSubSite(string subSiteName){

WindowsImpersonationContext impersonatedUser = null;

try{

newIdentity = GetIdentityWithPermissionsInSPS(); impersonatedUser = newIdentity.Impersonate(); using (SPSite site = new SPSite(spServerAddress))

{

using (SPWeb theWeb = site.OpenWeb()){
theWeb.AllowUnsafeUpdates = true; theWeb.Webs.Add(subSiteName);

}
}
}            finally {
if (impersonatedUser != null){

impersonatedUser.Undo();

}
}

}

We decided to change the Application’s Pool identity of our ASP.NET frontend application for the appropriate account with permissions for creating sites in SharePoint right away.

As soon we did this, the exception went away!

But, it isn’t a good idea to let our ASP.NET application run under the context of an Application Pool with such privileges. So we considered creating a new Web Service -which would be referenced from the ASP.NET application- responsible of calling the SharePoint API directly. This new Web Service will run in a new Application Pool configured with an identity with enough privileges for performing changes in SharePoint.Below is an image showing how this architecture was conceived:

In conclusion, we have performed a separation of responsibilities here; the ASP.NET application doesn’t have to know how to deal with SharePoint. For that reason, we created this new Web Service responsible of doing the “dirty” job.

I hope this post can help someone over there who might be working on a similar scenario. By the way, we are now starting a new project for another customer with exactly the same requirements, but we can use MOSS 2007 and WF, which is cool. So we’d love to hear any advice from you in order to have our new architecture more scalable, secure, stable and performing.

Posted written by Damian Da Silva - UruIT Global IT Services. Dev Team

Know Why Uruguay is the IT Outsourcing Paradise...

2008-02-11T12:33:00Z

Probably you don't have a clue about what "Uruguay" is or where it is located. Perhaps you heard about it in the news due to its importance in the Global Delivery Model offered by most of the Global IT Companies worldwide. In this post, you will learn more about this "paradise" for getting good software and IT services at low rates.

Uruguay is a small country (3 million people) located in the south cone of Latin America (just in the middle of Argentina and Brasil).

It has lot of cities with amazing beaches over the Atlantic Ocean, attractions for all kinds of public and it is visited by hundreds of thousands of tourists from all over the world, every year.

But Uruguay has been the choice of many of the major IT and non IT companies in the world (including Tata Consultancy Services from India and Sabre Holdings from US among hundreds) , to establish their software factories and call centers. This little country is also the largest exporter of software in the region !

But why ?

Well, Uruguay has some privileged advantages over other countries around the world. Here I'm listing the major ones:

Timezone: Uruguay's geographic location (GMT - 3) is great for doing business with U.S. and Europe. It is aligned with the U.S. east coast, and just a few time zones behind UK. This has been a clear advantage over other countries like India with so many hours of difference.
Culture: Uruguayan population is composed mostly of immigrants from Europe (Spain, Italy) and has received a lot of influence from US culture over the years. This resulted in a culture very similar to US and Europe. Friendly people everywhere, excellent communication skills, and committed to outperform in their jobs are some of the attractive qualities found by foreign companies.
Education: Even when it is legally free, the quality of the Software Engineer career (almost 6 years in total) is above the average within the region and other countries around the world (based in my experience working for foreign companies). There are also paid universities (i.e. www.ort.edu.uy) where courses are even more aligned with the latest technology trends (specially Microsoft). As a result, even when there are not so many new Software Engineers \ IT Analysts every year, they do have a deep background not only in DB design and Software Development with different technologies (mainly .NET and Java), but also with Calculus, Physics, Quality and other Software related processes and areas.
Government support: Exporting Software from Uruguay has no taxes. This is one of the key laws written by our government to encourage the development of this industry.
Costs: As a direct consequence of the above, Uruguayan rates for resources and facilities are much lower than in other countries. Even when it is not as cheap as India, you get qualified resources for less money. I think this might be one of the main advantages for big IT companies who are trying to minimize their costs.
Communication: English and French can be learned for free in most of the education centers. Different telecommunications companies provide video conference and VoIP facilities, which allow companies here to have their virtual teams just the same as if they were onsite.
Others, many other advantages...

All that being said, Uruguay is definitely one of the best choices for outsourcing your software development projects. You will find big and small IT companies established here, some good, some not so good, also with a variety of rates.

Our company is a great example of an IT company based in Uruguay and taking advantage of all the above points for the past 6 years.

I've been working at UruIT forming a group with some of the best .NET developers and architects from Uruguay. We are doing Software Development and Nearshore Outsourcing from Montevideo, with the latest .NET technologies. We are now exploring new areas such as Testing, BPO and Production Support.

We handle several projects for different customers located in U.S., U.K., South America and Uruguay.

If you are interested in exploring opportunities for your company not only to reduce your costs but also to get an outstanding service, just drop me a line or a comment and I'll be more than happy to get back to you with some help.

-- Posted written by Marcelo Lopez. .: UruIT: Global IT Services. R&D