In about nine weeks we should be able to find out the sex. At that point, I can begin registering his or hers domain name.

Anyway, I’m very excited about TouchPointCMS development. It’s looking to be a very promising and solid CMS with endless add-on functionality. It’s also amazing how much faster this version runs over the old adhoc’d versions. One of the last updates to TouchPointCMS was improving the caching mechanisms used throughout the site in order to decrease load times and save on server resources.

I’m also finding that writing add-on modules now is incredibly easy. For example, we’re deploying TouchPointCMS for smart-spice.com and they want to include a spice manager. We can do this pretty quickly, considering a basic module consists of roughly 3 core files (5 if using code-behind):

• The user control that the end user sees (.ASCX and .CS)
• The user control that the CMS user sees for management (.ASCX and .CS)
• A meta.config file for SQL related to installation, deletion, generating instances, icon, etc.

Essentially, that’s all you need for building a module. For the spice manager, I combined functionality from the included Blog and Photo Gallery modules to allow for a simple spice list manager with images. The front end user control is nothing more than a ASP.NET ListView control bound to the spices for that page.

The modules that you create are automatically loaded with the web page. If you want to customize the placement of the module, such as having a Events module off to the left or right sizes of your page, you can deselect the Render Inline Module option from the CMS. This will disable the automatic rendering of the module, allowing you to use the <tpc:Event runat=”server” /> instance to create a list of events wherever you like on your template file. If you want to use events from another page, just include the PageID=”6″ attribute, where 6 is the page ID you wish to pull from.

Check back later for updated CMS development and release!

Learn more about TouchPointCMS.

TouchPointCMS hopes to alleviate this, at least to an extent. After all, if we had a perfect solution, we’d all be developers. TouchPointCMS contains template folders, inside a dedicated templates folder located at the root. Inside the templates section of the CMS, you will see the list of template folders available, along with the one that is currently active. Inside of each template folder is essentially your entire website. By this, I mean that you’ll have any style or script folders, along with your content pages, such as home, interior, custom, etc (these pages must be ASP.NET pages ending in .ASPX).

The idea is that each content page will have a unique structure if needed. For example, your home page may contain a large introductory banner which will not be part of interior pages. You may have a page containing a sidebar of events or other content. Because TouchPointCMS is aimed at those who are even a little web savvy (and who isn’t these days?), the idea is to use the built-in Controls and Modules inside of these templates where needed. An example of a module can be <tpc:PageContent />, which will automatically display any content for that page or any type (such as a gallery page, or a web form). You may also choose to display individual modules anywhere you like on your template, such as <tpc:Form /> to display the web form for that page. Specific controls such as RichNavigation to enable a rich drop-down navigation bar, BreadCrumbs, for showing your depth in the website, or Topic, for showing a reusable section of HTML content throughout your site.

Once your templates have these modules, they can then be assigned to pages in your site. On the templates page in the CMS, you may not only choose your overall template, but set a default template for all your pages. Individually for each page, you may assign a template (home, interior, etc) from those available when editing that page in the CMS.

There is one requirement however. All your pages must use an ASP.NET Master page. Before getting scared, this is simply a shell to be used around all your template files. For example, we can assume that all your templates will have basic HTML elements that can be used throughout, such as html and body tags, as well as a list of included CSS and JavaScript files. Master pages are a good practice, as they enforce the re-use of content. You can have as much or as little repeated content in your Master page as you like. You may even have multiple Master pages. Also, in order to tie into the CMS, the Master page(s) must inherit from the TouchPointCMS.Core.Template class. Taking a look at one of the included modules will provide much insight to the basic structure.

From that point on, the rest is populating your site. Check back for more TouchPointCMS overviews!

Learn more about TouchPointCMS.

• Read more about TouchPointCMS »
• Online Demo »
• Screenshots »

There are several pre-defined events, providers, and rules inside the root web.config file in the same directory as machine.config (not to be confused with the web.config in your application). In the healthMonitoring section you will see several groupings for providers, rules, profiles, and event mappings. For right now, we’ll focus on providers, rules, and eventMappings. I’ll discuss how these play into logging events.

Providers (<providers>) essentially tell where the log information is going. For example, the provider named EventLogProvider maps to the EventLogWebEventProvider class. As you’d expect, this provides all those error events you see in your Event Viewer. Similarly, the SqlWebEventProvider allows you to log events to the built in ASP.NET database (ASPNETDB.mdf in your app_data folder or your own SQL Server instance configured using aspnet_regsql.exe). Web can define a custom provider in your application web.config file (or in the root if you want to apply it to all your sites) to, for example, generate and send an email to a recipient containing logged event information. The SimpleMailWebEventProvider does just this. We will define this provider and use this provider in our example below.

Rules (<rules>) dictate which event type will use a provider. For example, you can have application errors write to the SQL provider or generate an email using your the email provider mentioned above. The eventName attribute, when adding a rule, specifies the name of the web event to use. Basically, for each rule, you specify the eventName and the provider. Simple as that.

Event Mappings (<eventMappings>) are used for mapping event names to provider classes. In the root web.config, you will notice several pre-defined provider names associated with event classes (the type attribute). If you are creating your own web event class (we’ll cover this in a later post), you may create a name for it and give it a type (your new class). By default, you can leave these alone, as the web events shipped with the framework cover most cases.

There are several event mappings listed, but there are usually one or two which, I feel, would be used in most conditions. First, the All Errors event mapping (using WebBaseErrorEvent) is used for all compilation, runtime, and configuration errors. I have found this to be the most handy. The second is the Failure Audits event (using the WebFailureAuditEvent class), which raises a an application page is accessed using improper credentials. By default, ASP.NET uses the NETWORK SERVICE account to access the file system, the registry, any databases, etc. If incorrect permissions are set in the file system, or malicious code is attempting to access the file system, this event will be raised. One other potentially useful web event is the Infrastructure Error mapping. This web event is raised only for compilation and configuration errors. However, I personally find it less useful, as the All Errors web event covers this.

In this post, I will create a basic health monitoring event handler using the SimpleMailWebEventProvider class to generate an email whenever any runtime error is found on the site. The email, by default, will provide all the information I need to diagnose the error and make corrections. You may customize this email template, but that is another topic.

First, since we’re using an email provider, we need to configure SMTP settings in the web.config. The SimpleMailWebEventProvider class will use these settings for sending the email. Configure your SMTP settings as follows:

<configuration>
    ...
    <system.net>
        <mailSettings>
            <smtp deliveryMethod="Network">
                <network host="SERVER" userName="USERNAME" password="PASSWORD" />
             </smtp>
        </mailSettings>
    </system.net>
    ...
</configuration>

Once that is entered, we can begin enabling the health monitoring features and chose our provider and rules. Again, the purpose is to create an email for all site errors and send them to my email address.

<system.web>
    ...
    <healthMonitoring enabled="true">
        <providers>
            <add name="EmailSiteErrors" type="System.Web.Management.SimpleMailWebEventProvider" to="ryan@marriedgeek.com" from="noreply@marriedgeek.com" buffer="false"/>
        </providers>
        <rules>
            <add name="Email Errors" eventName="All Errors" provider="EmailSiteErrors"/>
        </rules>
    </healthMonitoring>
    ...
</system.web>

That’s pretty much it. The ease of configuration and separation of providers and rules makes it a breeze to configure monitoring for your website. If you chose to use a SQL event provider, your logs will be written in the  provider database configured in your maching.config’s connection string. You may even have both or as many provider/rule sets as you like.

This is an overview of how to get started with using health monitoring in ASP.NET. To read more about health monitoring, check out the following links:

• Health Monitoring in ASP.NET 2.0 (forums.asp.net)
• ASP.NET Health Monitoring Overview (msdn.microsoft.com)

The cam is usually on during work hours. Enjoy.

A few entries ago we talked about custom server controls and mentioned how to structure a composite control to allow the ViewState to “pick up” on it’s post back content so that data isn’t re-binded with every call. It was a very basic composite control, but it showed how to add native WebControl objects to the Controls tree to create a basic layout without using a .ASCX design file. This type of control can be added to your app_code directory or manually compiled as an assembly and placed into your bin directory. The advantage of the latter is to feasibly add it to your Visual Studio toolbar by loading the assembly. This time, we’ll add a custom event to our control using a delegate for an event, as well as a custom event argument class to pass along with it.

We’ll take the code from last time, but add several things which are highlighted in green.

• A line to declare our event delegate variable and the delegate itself.
• A class which will be used for our arguments.
• A binded event for the button Click.
• A line in the button Click handler to invoke the event delegate.

using System;
using System.Web;
using System.Web.UI.WebControls;
using System.ComponentModel;

namespace RyanControls
{
    public class MyCompositeControl : CompositeControl
    {
        public MyCompositeControl() { }

        // Declare the Updating event of delegate type CustomControlUpdateHandler
        public event CustomControlUpdateHandler Updating;

        protected override void CreateChildControls()
        {
            TextBox txtMyData = new TextBox();
            DropDownList drpMyList = new DropDownList();
            Button btnUpdate = new Button() { Text = "Update!" };

            Controls.Add(drpMyList);
            Controls.Add(txtMyData);
            Controls.Add(btnUpdate);

            if (!Page.IsPostBack)
            {
                drpMyList.Items.Add(new ListItem("item 1"));
                drpMyList.Items.Add(new ListItem("item 2"));
                drpMyList.Items.Add(new ListItem("item 3"));
            }

            // Add a handler for the button click to launch the Updating event
            btnUpdate.Click += new EventHandler(FireEvent);
        }

        // The method that handles the Click event from the button
        // and triggers the Updating event by calling the delegate
        protected void FireEvent(Object s, EventArgs e)
        {
            Updating(s, new CustomControlUpdateEventArgs() { SomeData = "The control was updated!" });
        }
    }

    // Our custom event class that inherits EventArgs. You may use
    // EventArgs as the class if you don't have additional data to pass
    public class CustomControlUpdateEventArgs : EventArgs
    {
        public CustomControlUpdateEventArgs() { }
        public String SomeData;
    }

    // The delegate declaration (or template, as I call it) for the handler
    public delegate void CustomControlUpdateHandler(Object s, CustomControlUpdateEventArgs e);
}

There you have it. If you place this code into a .CS file inside your app_code directory, you’ll be able to include the control on your pages. If you compiled it into an assembly, toss it into your bin directory and feel free to add it to your toolbar in VS or VWD.

<asp:MyCompositeControl runat="server" ID="cntMyControl" OnUpdating="DisplayUpdate" />

By assigning an event handler for the Updating event (the page automatically prepends the “On” for “OnUpdating”) to call a method to handle the update, you can use data contained in the CustomControlUpdateEventArgs object. In this case, there’s only a public string called SomeData.

protected void DisplayUpdate(Object s, RyanControls.CustomControlUpdateEventArgs e)
{
    Response.Write(String.Format("<div>From the event handler: {0}</div>", e.SomeData));
}

When you run the code and click the button, the method will be invoked and the message displayed. Similarly, you can bind the handler programmatically by adding cntMyControl.Updating += new RyanControls.CustomControlUpdateHandler(DisplayUpdate) in your code-behind.

So again, while the code isn’t really useful, it shows how to create your own event handlers and custom argument class(es) for a composite server control. The point is to be able to create one or more event handlers, as well as combine those with one or more types of event argument classes. The fields of that particular argument class should be specific to that type of event and it is best not to use one custom event args class to satisfy many types of event argsuments, unless the data being passed into your hander functions generic enough to do so.

Happy coding!

You can do a lot with a home server. Some things may you may find more interesting depending what stuff you’re into, but here is a broad list:

• Backups – This is by far the biggest benefit. If you’re not using automated backup software on your computers, you run the risk of a catostrophic failure (usually in the form of a dead or dying hard disk) and losing all your files. With a server, you run scheduled backups one or more times per day to grab those files off your PC or laptop and save them to your server.
• Media storage – Have a lot of music, videos, or photos? Have a spouse or kids who want access to that content? Instead of sharing one computer, store all your media on a drive connected to the server and allow for anyone to access that content any time from their own computer.
• FTP server – If you’re on the road a lot or just want access to your files, you can set up an FTP (file transfer protocol) server, allowing you to grab and/or save files to or from your server from anywhere you can steal an internet connection.
• Remote desktop – If you need to connect to the desktop of your server while you’re away, you can connect to it and view any documents or backups.
• Web server – While the first two are pretty common, running your own web server involes a bit of skill, including setup of your web application software (e.g., IIS, Apache), configuring your router and firewall, installing databases, etc. This can be a daunting task to someone new, but you can host your own websites, even your WordPress blog, from your server for free! With free DNS services out there, such as Afraid.org, as long as your ISP lets you hang onto your IP, all you have to pay for is the domain name.
• Host your own email – This one can be tricky, especially when dealing with blacklists. With free email tools out there for Windows, such as hMailServer, you can setup POP or IMAP email for your domain. You can even run backups of your email.
• Gaming server – Yes, you can have a wicked LAN party and have your server host all the games. Ask your wife about having the party first.
• Streaming webcam – I used this idea when we got our new dog and I wanted to keep an eye on her while at work. By hooking a webcam, and using some streaming software, I was able to connect to and stream video from the camera.

The concept of having a home server is pretty simple. You have a computer running 24/7 on your home network. It’s connected to your router and can talk to other machines on your network. By “talking” to other computers on your network, it simply mean that it can view their folder contents as well as allow its contents to be viewed by other computers on your network.

For this intro, I just wanted to cover the basics and give an overview of what a home server can do for you. For next time, I’ll discuss how to pick a computer, connect it to your network, and set up shared folders.