First Approach: The Specific Repository

The specific repository implementation takes us to have a interface for each entity that defines all of the data access methods that we need to perform.

So, if we want to access data from a Customer, we would build first a ICustomerRepository and and LinqCustomerRepository that would implement our interface:

Has you can see, we have a method for each action we want to perform. While this implementation serves the repository purpose, to me it feels more like a Service layer .

Second Approach: The Generic Repository

This approach uses a generic interface and implementation for the common actions:

This approach, to me, reflects more the repository pattern in the current available technology allowing us to have  simplicity in our repositories thru the use of generics.

With this approach we also might use the Specification pattern for querying the data container.

The Specification Pattern

With this pattern we can encapsulate our queries. To perform this task we must first create a abstract class that will serve as base for all our queries:

With this we can now, for instance, create a query to get all customers by gender:

To use it in our Service Layer we just need to:

Our Find method of the Repository will get all:

          

• Sure we get all the job done quickly but,
• We end loosing control over part of our code.

Another issue is that if you, like me, like to create tables with and organize them with schemas, the designer complete ignores the schema.

In my latest pet project I used a Microsoft tool called SqlMetal:

The SqlMetal command-line tool generates code and mapping for the LINQ to SQL component of the .NET Framework.

With this we can build our POCO classes and use the generated mapping from SqlMetal with the bonus of it mapping the schemas as well.

Generating the map file

So, to use it we just need to run our SqlMetal command:

So we need to tell where is our database (using the /server and /database parameter) and to where we want to generate our mapping file (with the /map parameter). We also need to use the /code parameter with the /map but the file generated is of no use to us since we want to have our “own” classes. We end up our command with the /namespace parameter were we identify were our classes will reside.

The generated map file will help us in the creation process of our POCO classes.

Creating our POCO classes

As we can see from the image above, our mapping file defines for each table a type element. Notice that this element has a Name attribute. This will be the name of our POCO class.

Now we have to options. We can use this name, in the format tableSchema_tableName , or we can rename our class. For the propose of this sample we will leave it.

So taking the example from the image above, we create our Product_Details class:

Since we didn’t use the generated code file, we also need to create a DataContext helper class, that will use our map file:

That’s it. Lets take it for a spin:

Why is this better than using the designer? It sure takes more time to develop…

Has everything else, we have to think before using this approach. With this you can, for instance, start coding your app without even knowing if you will end up using a SQL Server or a Oracle database. You can also easily move the Model to another assembly, and leave the ORM part (datacontext and map file) in another.

POCO with EF

Now, since EF is taking over, I recommend reading this post from the EF team on how to use POCO with EF 4.0 .

          

Typemock is launching a new product for ASP.NET developers – the ASP.NET Bundle - and for the launch will be giving out FREE licenses to bloggers and their readers.

The ASP.NET Bundle is the ultimate ASP.NET unit testing solution, and offers both Typemock Isolator , a unit test tool and Ivonna , the Isolator add-on for ASP.NET unit testing , for a bargain price.

Typemock Isolator is a leading .NET unit testing tool (C# and VB.NET) for many ‘hard to test’ technologies such as SharePoint , ASP.NET , MVC , WCF , WPF, Silverlight and more. Note that for unit testing Silverlight there is an open source Isolator add-on called SilverUnit .

The first 60 bloggers who will blog this text in their blog and tell us about it , will get a Free Isolator ASP.NET Bundle license (Typemock Isolator + Ivonna). If you post this in an ASP.NET dedicated blog, you’ll get a license automatically (even if more than 60 submit) during the first week of this announcement.

Also 8 bloggers will get an additional 2 licenses (each) to give away to their readers / friends.

Go ahead, click the following link for more information on how to get your free license.

          

When this happens, it is fundamental that these applications can connect with a central repository where all the business data is located and consume it without leaving the application.

Creating a Office Business Application (OBA) to share your Line of Business (LOB) Data is extremely easy, and can enhance the user experience greatly.

For this demo let’s assume that we work in a large online shopping company. In the shopping portal, on each product page, the user was the possibility to email, thru a easy web form, the customer support to enquiry about the product.

This feature is heavily use by the customers. What happens is that, when a support team member receives the email, he was to access the intranet portal to gain more details about the product to more accurate answer the customer.

After a brief talk with the support team manager, we realized that the main working tool they use is Outlook, since all enquiries are send via email by the web form.

“We can improve this process!” we think out loud. “Since the email subject identifies the product ID, why not have Outlook show the product details?”, we ask. “That would be just great!” says the manager. (I’m getting a little bit esquizofrenic talking to myself…)

NOTE: This is demo code. No validation and performance was took in account.

So, what we need is to, when the customer support team member selects an email, our Outlook add-in will look the subject for the product ID, and if found, show a new region on the email message window detailing the product.

Since the LOB data is on a central repository, we need to develop first a service to fetch the data. For this task we will use the ADO.NET Data Services.

Simply put, ADO.NET Data Services let us expose our data as a RSS feed.

In Visual Studio 2008 create a new web application, and add a new Linq to Sql Class item:

Lets drag some tables from the store database to the L2S designer. We will end up with the following model:

Now lets add a new ADO.NET Data Service:

After adding our Data Service, we need to let him know which data context to use, in this case, our L2S OnlineStore.dbml. What we need to do is in the generic DataService class tell it to use the OnlineStoreDataContext, and next tell which entities we can use, in our case all (“*”) and set the usage rights, that in our case, we only need to read the data:

To test our service, just browse it:

As you can see we have easily exposed our data thru a service.

With this done, is now time to build our client, in our case, a Outlook add-in.

Lets start by creating a new Outlook add-in project:

The next step is to create the actual region that will be shown when we select a email message in Outlook. So, lets add a new Outlook Form Region:

The Outlook Form Region wizard starts. The first step lets us design a new region or import a Outlook form storage file. We will choose the first one: Design a new form region.

The next step let us choose which type of region do we want to create. To simplify the process of the support team, we will choose the “Adjoining”:

Next we are asked for the name of our region, and when should this region be shown. Since we only want this while we are reading the email, choose only “Reading Pane”:

Finally we just need to define which message class will trigger the display. In our case the “Mail Message”, which should be selected by default.

Clicking finish will make the designer show our new email region, which is a empty windows form user control.

Finally we will start coding something

Since we only want to show our region when the subject has a specific pattern, we will need to code this logic. So, hit F7 to go to the code-behind of our region.

Let’s first create a regEx to match our subject pattern:

Next, in the “ProductDetailsRegionFactory_FormRegionInitializing” event, we will add the code logic to see if we show or not our region:

Since we have some logic implemented we can test it to see if it works. Just select the Outlook add-in project and hit F5. The Outlook window will be showed to you. If any email message subject matches our pattern, our region will be shown:

Nice..it works! (has if we had any doubts… )

Now that we have coded when the region is shown, we need to add the service reference so we can display the product details.

Just right-click on the OBAOutlookAddIn project, select “Add Service Reference…”, click “Discover”, rename the namespace to “AcmeServices” and click “OK”.

In the designer of our region let’s add three labels:

Next, on the code behind, in the “ProductDetailsRegion_FormRegionShowing” event, lets add the product details logic:

That’s it! If we run our project we will have our product details showed to us:

Has we can see, sharing LOB data with Microsoft Office is easy and fast, allowing you to create full integrated applications using the latest Microsoft technology.

Download Code

          

Now, after been working with OutSystems for sometime, I believe that some improvement could be added, like:

Custom Controls

One thing that I think is critical and a major flaw in the OS platform is the lack of support for custom controls. Now a days this is simply mandatory. In the previous client, we had a huge library of custom, business-oriented, controls.

Extended Assign Editor

Another thing that could be introduced is a Extended Assign (Expression) Editor. When using the Assign Action, we can have, for instance, 30 assigns. Editing them in a property grid like editor may not always be the best(practical) solution. It would be nice to have a Extended Expression Editor for action that had multiple arguments. This Extended Expression Editor would have on the left side a treeview with all the arguments of that action.

Unit tests outside assemblies

This was a big “What the Heck” for me. While using Reflector to browser the OutSystems assemblies, I found out that many assemblies also contains the unit tests. Keeping it in one project requires extra bandwidth to distribute , extra build time and increases the installation footprint.

Master Pages

On the community forums there is a post about this topic with over a year. This is a much needed functionality. Please release it on the next version. Pleeeeaaaassseeee.

Docking panels

The OS Service Studio relies on panel for both application(eSpace) navigation and Tool box. This is just fine, but these panel are “fixed”. Or you see them or you…see them. It would be nice to have docking panel, like visual Studio. 

Editor Tabs

Another feature that could be added to improve user experience are the tabs. The latest release of the Service Studio introduced the navigation back/forward arrow, but is my believe that tabs would be much appreciated by the community.

Split Screen

Now this is just pushing, but split screen for the designer, action of a webscreen would be just soooo sweeeeeeet .

Shelves

This is a topic not related with the user experience, but more a programmer experience. Many times while creating a a webscreen, editing a action, or whatever task we can perform on the Service Studio, we have the need to save that change for later. A common scenario is when we are introducing a new, 5 days long feature, and on day 4 your manager says “We need to make a little change on that action.” . We can always save the eSpace, get the latest publish one, make the changes and go back to our saved eSpace.

For me it would be nice to have a “Shelve…” on the context menu. This action would save the changes to the OS Server for later usage.

This is a concept that we have, for instance, with Visual Studio and Team Foundation Server.

Conclusion

So, these are some of the features I would love to be added to the OS.

What do you think? Any suggestions?

If you haven’t already tried out the OS Platform, download the developer edition, learn how to use, and show it to your manager . It’s great for rapid application development.

          

Although developed in .Net, the OS platform just recently updated their tools to the 2.0 version of the .NET framework.

"So, what does this introduction has to do with the title?"

What happens is that I developed a HttpModule to add some meta tags to all applications under IIS.

All worked well until we started using one of the OS management applications. The error was: "The Controls collection cannot be modified because the control contains code blocks (i.e. <%…%><% … %>). "

"What the heck?!"

After browsing thru the OS management application page files, I found this piece of code on almost all pages of the application:

<head runat="server"
>

<title><%= HttpUtility.HtmlEncode (Title) %></title>
<meta http-equiv="Content-Type"
 content="text/html; charset=utf-8"
 />
<link href="web.css" 
type="text/css"
 rel="stylesheet" 
/><%= GetJavaScriptIncludes() %>
<script src="<%= OutSystems.HubEdition.RuntimePlatform.Web.JavaScriptManager.GetRelativeJavaScriptPrefix() %>_osvalidators.js"

 type="text/javascript" 
charset="UTF-8"
></script>
</head>

Has you can see, although the head tag as the attribute runat="server" they still use markup text (<%…%>). Has Rick explains , when using the markup text, the generated code for the page changes, and all markup text is translated to Response.write and the controls collection of the container is hardcoded living no room for adding new controls.

So for me, the big question is: Since the OS team updated their solution to the .NET 2.0 version, why didn’t they also upgraded the management application to use all the cool (and helpful) features? Why not use MasterPages? Why not use the ClientScript.RegisterClientScriptBlock and this.ClientScript.RegisterClientScriptInclude ? Why not use the Page.Title ?

          

• The ConditionalAttribute indicates that a method is callable if a specified preprocessing identifier is applied to the method.
• The #IF … #ENDIF Preprocessor Directive conditionally includes source code at compile-time if a specified preprocessing identifier is defined.

The ConditionalAttribute class

An practical example of the usage of this attribute is the framework itself. The System.Diagnostics.Debug class uses in its methods this attribute so that when you are debugging your assembly, the debugging information is output:

Let build a simple example:

using

 System;

using

 System.Collections.Generic;
using

 System.Diagnostics;

public

 class

 MyConditionalSample
{
    public

 static

 void

 Main()
    {
        Debug.WriteLine("Some debug info!"

);
        ExecuteIfRelease();
        ExecuteIfDebug();
    }

    [Conditional("RELEASE"

)]
    private

 static

 void

 ExecuteIfRelease()
    {
        Console.WriteLine("Hello world! I'm a release assembly!"

);
    }

    [Conditional("DEBUG"

)]
    private

 static

 void

 ExecuteIfDebug()
    {
        Console.WriteLine("Hello world! I'm a debug assembly!"

);
    }

}

This is a straight forward example. In the Main method we call the Debug.WriteLine method to output some debug info, and call both ExecuteIfRelease and ExecuteIfDebug methods.

Looking at these methods, notice that they have the Conditional attribute with the conditional compilation symbols RELEASE and DEBUG.

So, on our command line we will first simple compile and execute our code:

As you can see, no output was wrote, this because no conditional symbols were defined in our compilation. Let’s change our compilation command to include the RELEASE symbol:

Now that we added the RELEASE symbol, the runtime now executes our ExecuteIfRelease method.

Changing the symbol to DEBUG will now make the runtime execute the ExecuteIfDebug method and also output our debug message, that we can trace in the DebugView:

If we look at our compile code in the .NET Reflector we will see that both methods are declared on the code but only the ExecuteIfDebug method is declared on the Main method:

#IF … #ENDIF Preprocessor Directive

The #IF…#ENDIF preprocessor takes this to another level. When using this directive, you are telling the compiler to include/exclude code from the compiled assembly.

So, taking our example and changing it to use instead this directive:

using

 System;

using

 System.Collections.Generic;
using

 System.Diagnostics;

public

 class

 MyConditionalSample
{
    public

 static

 void

 Main()
    {
        Debug.WriteLine("Some debug info!"

);
        #if

(RELEASE)
        ExecuteIfRelease();
        #elif(DEBUG)
        ExecuteIfDebug();
        #endif

    }

    #if

(RELEASE)
    private

 static

 void

 ExecuteIfRelease()
    {
        Console.WriteLine("Hello world! I'm a release assembly!"

);
    }
    #elif(DEBUG)
    private

 static

 void

 ExecuteIfDebug()
    {
        Console.WriteLine("Hello world! I'm a debug assembly!"

);
    }
    #endif

}

Now let’s compile and execute our code using the DEBUG symbol:

The code executed has expected, with no visible difference from the prior sample. So what’s the catch?

The catch, has told, is in the compiled code itself:

Notice that our compiled code doesn’t include the ExecuteIfRelease method.

Conclusion

So there you have it. To simple ways of call conditional code. One more thing: although we used the command line compiler to define de conditional symbols, the same can be made using Visual Studio. Simply go to the project’s properties, and on the Build tab set your custom compilations symbols, or use the DEBUG and/or TRACE symbols:

I would like to say thanks to my good friend Paulo for pointing me into the right direction on this matter.

          

Getting Funambol to work is extremely easy:
First get a terminal window and download the package:

# sudo -s
# wget http://download.forge.objectweb.org/sync4j/funambol-7.0.6.bin

Then just install:

# sh funambol-7.0.6.bin

Using the default directory for the instalation, start the funambol server:

# /opt/Funambol/bin/funambol start

On your browser you can now type http://localhost:8080, hit Enter and voila, the DS Server page is shown.
Here you can browse to the Web Demo client and loging as a guest.

To manage the Funambol server, we user the Admin applet by executing:

# /opt/Funambol/admin/bin/funamboladmin

After login (File > Login user:admin password:admin), we can now manage the server, and, for now, create a new user, by expanding the tree till we reach the Users node and adding a new user.

So, for completing this first step, all we need to do is install the mobile client. I’m using the Funambol client for windows mobile. Many other clients are available, like for iPod, BlackBerry, Outlook, Java capable phones and of course, the iPhone.

After installing the client and setup the account details, just hit “sync all”, and all your data will be placed on the funambol server. (note: I’m assuming that the device used in this step is, for now, can access the local network where the funambol server is located).

Now, I need to configure the server to be accessible “over the air”. This was, for me, the hard part since I didnt knew much of Apache and Tomcat.

Since this is a LAMP server, I’ll be using the Apache web server as a reversed proxy to the “internal” tomcat server used by Funambol.

Assuming that the domain funambol.domain.tld is poiting to the LAMP server public IP, all we need to do is add a proxy reditection from the Apache to the Tomcat using Apache VirtualHosts:

# gedit /etc/apache2/sites-available/default

In the editor, add a new VirtualHost element like so:

<VirtualHost *:80>
ServerAdmin webmaster@localhost
ServerName funambol.domain.tld

ProxyPass / http://localhost:8080/funambol/
ProxyPassReverse / http://localhost:8080/funambol/

ErrorLog /var/log/apache2/error.log
</VirtualHost>

Now we need to enable the apache proxy be editing the proxy.conf file:

# gedit /etc/apache2/mods-available/proxy.conf

And allowing proxy from all, like the code bellow:
ProxyRequests Off

<Proxy *>
Order deny,allow
Allow from all
</Proxy>

If all went well you will now be able to access the Funambol server throu the client using the funambol.domain.tld url.

Hope that this little tutorial can help you out setting up your own Funambol server.

The next steps, for me, will be getting Funambol to work with Google Calendar and also with Zimbra.