David Higgins

Adobe Flex and Flex Charts, OnTime 2007 SDK Sample

David Higgins — Tue, 24 Apr 2007 18:35:00 GMT

Have you been wondering what all the hype was about Adobe Flex? Ever wondered what it was, or what it could do for you? Well, Dan Suceava and I spent a day or two looking into it, and this is just a quick and simple example of what we came up with.

We downloaded the latest version of Adobe Flex Builder and Flex Charts and start digging around, after a lot of trial and error we eventually managed to throw together something that we were both quite happy with. As usual, I'll start with the eye-candy before going into details, so check out this video recording of our 'OnTime SDK Flex Chart Demo' (included in the OnTime SDK Examples).

As you can see in the video, we created an 'advanced' charting tool with Adobe Flex, ActionScript and a custom .NET Web Service. This was all, for the most part, fairly simple, once we wrapped our heads around the concept of coding in ActionScript and the oddities that are Flex Component Design. When I first looked into Flex, I was overly impressed with the look and feel, and the demo's and marketing pages from Adobe made it look so cool, I just had to try it out. After fiddling around for quite some time with it, and producing this seemingly simple sample, my enthusiasm quickly dissipated.

Not to say that Flex is horrible, it's just not my style. You create MXML files, which contain 'components' which are, for the most part, custom controls. In these controls, you can place other controls (very similar to .NET User Controls). All your controls, in the designer anyhow, are created through Markup, which is ... again, very similar to ASP.NET Markup. The tools available for the creation of Flex application, Adobe Flex Builder (built on Eclipse), are ... how do I say this right ... lacking? Very clunky, IntelliSense works ...sometimes, Code Highlighting ... almost all the time, type-ahead ... ack, it works, and it does things that drove me nuts! Granted, most of these tool related issues are probably configurable in the options somewhere, but wow, the defaults drove me mad.

I won't speak for Dan, but I'm pretty sure he wasn't digging the tool set either.

All in all, I can see Flex working for quite a large majority of developers, I'm just not one of them. I attempted a few various projects at home on my free time, and couldn't get most of what I wanted to do accomplished without extending the default controls (which, thanks to Adobe, full ActionScript source is provided for all tools, which was nice!).

So, with all that said, let me explain how we put this whole thing together.

Requirements:

Visual Studio 2005 (Web Service)
Adobe Flex Builder 2 (Trial is OK to Build Demo)
OnTime SDK
Adobe Flex Charts (Trial is OK)

Time Invested: 16 work hours (10 hours research, 6 hours code)

First, we installed Adobe Flex Builder, along with the Flex SDK. We then created a new Flex Application Project, and added a Flex Application, and 3 Flex Components. The first component was called 'ChartWindow'. We placed the 'ChartWindow' component into our Flex Application. The ChartWindow component contained our Application menu and the User List box, which we attempted to have populated directly from the OnTime SDK. However, ActionScript was not able to understand the DataSet XML Structure returned by the OnTime SDK, so we whipped together a really quick wrapper Service that tied everything together fairly neatly. I believe it also helped reduce some of the more hassling code we would have to have written if ActionScript did understand the DataSet structure.

NOTE: Dan did some research on the DataSet issue and found that there was at least one commercial ActionScript component which was able to understand the full range of .NET Web Service XML Structures, including DataSets.

For the Web Service Wrapper, we wrote a GetProjects and GetUsers method, which simply returned an ArrayOfUser and ArrayOfProject (we actually created wrapper classes for OnTime Users and Projects, to reduce the bandwidth overhead for the Flex Application). We then placed a Flex Web Service component into the ChartWindow code and attached it to the wrapper and binded to the two methods. We wrote 'result' handlers which basically built a collection of objects in ActionScript (this was actually pretty cool, ActionScript automatically converted the returned XML into Objects for us) and then added the drop-down lists and listbox code to populate from these collections.

After we got all this working, we immediately started tackling the Charting and we decided to split the top and bottom charts into separate components to help manage the code a little easier. We started with the chart on the top, since it's the controlling chart. We spent some time playing around with different features and functionalities available and eventually wound up with what you saw in the above video.

When the user changes there filtering options (clicks a User in the List or changes a Drop-down value), we call an 'update' method which basically retrieves all of the data from the wrapper Web Service again, using the filtering options currently selected. In the 'result' handler for this call, we build an Items Collection and then pass this collection into the two charts. Each chart component (top and bottom) handles the collections differently, the top chart always aggregates on the Status or Priority and shows an overall 'big picture' pie chart, while the bottom chart is provided with the top charts current selection and shows the 'overall details' of the current selection. We also thought that a nice Bar Chart showing Estimated vs. Actual durations would be somewhat fun, so we tossed that in there as well.

When we finished with all of the coding, we grabbed a backup of the Axosoft production database for the OnTime product and gave it a test whirl. It performed spectacularly, almost no hesitation, even when loading large sets of data (1000+ items for a single user). I must say, after going through the struggle of getting this demo finished, both myself and Dan were extremely happy with the results. I personally had some issues with the path to completion, but wow ... it's like hiking up a large rugged mountain, the hike can kill, but it's all worth it when you reach the top and look at the view below.

Flex has quite a few really cool things, and I can't really knock it too much cause I did have fun writing this charting demo. I just can't see myself doing this type of coding for a living -- but the next time I need something visually stunning and web-based (with Apollo, you can even make it Desktop based, Oh no!) I am definitely going to give Flex the benefit of the doubt and try to utilize it. Hopefully, with some more time invested into the technology, it may wind up being the next greatest development platform (who knows -- could happen).

To download the full source to this sample, goto the download page.

OnTime 2007 SDK - System Tray Notifications, with Fading Windows

David Higgins — Mon, 23 Apr 2007 21:52:00 GMT

By now, you've probably realized that I've spent the past few days working on some SDK Samples, and, here's yet another OnTime SDK Sample. I tried to focus on SDK Examples that were both educational about the SDK, as well as the possible uses of the SDK. Our previous SDK Examples were more focused on the actual use of the SDK, and not the practical uses of it -- such as Integration with Microsoft Office Tools (Outlook, Project, etc), and so, here's another practical use for the OnTime SDK.

For those of you who may wish to be notified about OnTime items being assigned to you, when they become assigned to you, this little example will be a great starting point. Basically, the purpose of this example is to try to mimic the "You've got new Mail" functionality of most common email readers. This sample would most likely find itself extremely useful in Help Desk related positions where response times are critical to the success of your Help Desk.

Now, onto the eye candy.... cause we all know, I can say 100 different things, but these pictures say 1,000,000 :)

Here's an example of the 'Notification Window'

Here's the "Quick View", with a Grouped List Box

Here's the Tray Menu

Here's the Options Window

Here's the "Quick View" with Tabs Enabled

Here's the Notification Window, you can't really tell, but it's Fading Out

Oh and, since we got new Tasks, they are Highlighted
and you can see the 'Mark as Viewed' option as well

Requirements:

Visual Studio 2005
OnTime Client
OnTime SDK
Diffuse Dialog Resource

Time Invested: 6 work hours (2 hours research, 4 hours code)

To create this sample, I searched Google for an example of Fading Windows, and found a CodeProject.com resource called Diffuse Dialog. I then created a C# Windows Project in Visual Studio, and started adding my Web References to the Task, Defect, Feature, Incident and User Services. I used the User Service to retrieve the UserId of the specified user -- I then modified the Diffuse Dialog example a little, to extend the period of time the window stays 'up', and I created a Notifications List which stored a reference to my 'notifications', which were simply just text and item types so I knew what type of message to display --- if only one item exists, you got a nice "You have a new Task" message -- if you had 4 tasks, you get a nice "You have new Tasks" messages, if you have a mixture of Tasks and Defects that are new ... "You have new Items". Which, worked out quite well.

So, basically, it's just a little application that sits in your system tray (next to the clock) and checks the OnTime SDK every X minutes to see if you have new items. It also allows you to see a "Quick View" of all your assigned items at a glance (using a Grouped List Box). Double Click any item in the Quick View, and the item is launched in your default Browser right to the 'View Item' page in OnTime Web.

To download the full source to this sample, goto the download page.

Design your Project in Microsoft Project, Manage it in OnTime!

David Higgins — Mon, 23 Apr 2007 16:19:00 GMT

As the title suggests, this article will describe how you can utilize Microsoft Project to Design your overall Project Layout and Manage it with Axosoft's OnTime 2007. Provided with this article is complete source, written against the Office .NET Assemblies and the OnTime 2007 SDK.

As usual, let's see some eye candy first, then we'll go into details ...

Here's the actual startup form, the source provided allows for a
single command-line parameter to be passed, which is the path
to the MS Project (*.mpp) file to import

Here's a standard .NET 'OpenFileDialog', and we're selecting the example project

Here we are, selecting the OnTime 2007 Project
to import the MS Project items into

After selecting 'Convert', you'll see MS Project launch and open the Project (*.mpp) file you selected --
and look, is that a Gantt Chart?

Here, we disable all the form controls, and show
a progress bar (this bar cycles twice, and I'll
explain why in a minute)

Here's a nice "Complete!"
notification popup

And here's what the tool looks like after it's complete ...

Ok, now after seeing all that, your probably sitting there going ... "Huh?". Trust me, I wasn't too impressed with the screenshots either, and I wrote the thing ... BUT, you want to know why this is so cool?

You do? Good ... picture this, one thing I've come across in my various positions over the years is a Project Manager using Microsoft Project to design a general time-line and work schedule, almost every one of these Project Managers turns around and spends just about as much time as they did designing the MS Project layout as they do trying to convert it into something that their employee's can work with, in this case, a Project Management Tool such as Axosoft's OnTime. Why do Project Managers like to use Project, simple, it's got Gantt Charts and all sorts of other nifty scheduling functionalities that allows the Project Manager to design an efficient schedule. Why do the spend so much time converting Project layouts into tools like OnTime, again, quite simple, OnTime has the tools and functionality to get things done.

The Technical Details

Requirements:

Visual Studio 2005
Microsoft Project 2003
Microsoft Office .NET Interop Assemblies
OnTime Client
OnTime SDK

Time Invested: 4 work hours (2 hours research, 2 hours code)

Now, onto the more technical details, and this time, I'll actually get into some source in the post, since in all honesty, this example is quite simple and contains very little source.

First, we create a new Windows Application in Visual Studio, and after the solution has been created your going to add a reference to a few things, and they are;

COM -> Microsoft Office 11.0 Object Library
COM -> Microsoft Project 11.0 Object Library
Web -> OnTime SDK Task Service
Web -> OnTime SDK Feature Service
Web -> OnTime SDK Project Service
Web -> OnTime SDK RelatedItems Server

Once you've added all the above references, add a form Windows Form to the project (or open the default form if one exists in the project) and drop two Labels, one TextBox control and one ComboBox control, two Button controls and a progress bar. Also, while your at it, toss an OpenFileDialog into the form as well. We'll name the first TextBox "txtMSProject" and the ComboBox will be called mbProjects. We'll put the first label to the left of the TextBox and put "MS Project:" as it's Text, and the second label next to the ComboBox and give it the value of "OnTime Project:".

Place the first Button to the right of the TextBox, and give it the value Text value of "..." and assign the following code to the Click event:

private void bBrowse_Click(object sender, EventArgs e) { openFileDialog1.ShowDialog(); txtMSProject.Text = openFileDialog1.FileName; }

Now, for the Forms Load event, we're going to grab a list of all the Projects available in OnTime and add them as objects to the ComboBox. To do this, I created a custom 'OnTimeProject' class which contains the ProjectId and ProjectName and an override for the ToString() method so that the ComboBox displays the Project's Name rather then the Class Name.

Here's the code for the OnTimeProject class;

public class OnTimeProject { public string Name; public int ProjectId; public override string ToString() { return Name; } }

Now, to get a list of all the projects from the OnTime SDK, we create a ProjectHandler object instance and then call the projectHandler.getAllProjects(Guid SecurityToken) method. This will return a DataSet, containing all the information you'll need to know about your OnTime Projects, we then do a 'foreach' loop through this DataSet (more specifically, the first tables DataRow collection, 'Rows') and create a new OnTimeProject instance and assign the Name and ProjectId and add it to the ComboBox's Items, here's the code for that;

protected override void OnLoad(EventArgs e) { base.OnLoad(e); OnTimeProjects.ProjectHandler projectHandler = new OnTimeProjects.ProjectHandler(); DataSet otProjects = projectHandler.GetAllProjects(securityToken); foreach (DataRow dr in otProjects.Tables[0].Rows) { OnTimeProject p = new OnTimeProject(); p.Name = (string)dr["Name"]; p.ProjectId = (int)dr["ProjectId"]; cbProjects.Items.Add(p); } }

For clarification, the 'securityToken' parameter passed to GetAllProjects() is a Guid defined in the source that contains the same Guid value as the OnTime SDK's Web.config SecurityToken value -- this is used as a security measure, to prevent unwanted users from accessing data from your OnTime SDK without authorization.

Now, with what we have so far, you should be able to test-run your code and your ComboBox should be pre-populated with your projects from OnTime and your 'Browse' button should allow you to locate and reference a file, storing it's value in the txtMSProject TextBox.

Now for the fun part, let's do some Microsoft Project Automation!

To launch an instance of Microsoft Project, or reference the currently running instance, you need the following code;

ApplicationClass prjApp = new ApplicationClass();

This prjApp has a number of properties available, and were going to set the Visible property to true. This is not necessary, but is helpful for debugging, by default the Application is hidden, unless it's referencing an already running instance of Microsoft Project.

To open an MS Project File (*.mpp), you use the FileOpen() method in the ApplicationClass, for this example, were not really concerned about most of the parameters passed to this method, so we pass Type.Missing rather then null.

string fName = txtMSProject.Text; prjApp.FileOpen(fName, true, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, PjPoolOpen.pjPoolReadOnly, Type.Missing, Type.Missing, Type.Missing, Type.Missing);

You'll notice the PjPoolOpen.pjPoolReadOnly value passed, this prevents our code from altering the MS Project file in any way, as the file is opened in Read-Only mode (again, not absolutely necessary, but a nice safe guard). Once you've opened your Project file, it becomes the ActiveProject and can be referenced by the prjApp.ActiveProject, which is a Project object instance.

Now that we have a Project reference, we can begin going through all of it's tasks, which are in the Tasks collection, a property of the Project class.

foreach(Task task in project.Tasks) { }

So far, we've got the skeleton structure of our converter, now let's create some OnTime Tasks and introduce them into our OnTime database, ok?

Let's create an instance of the TaskHandler class, this will allow us to call the AddTask() method.

OnTimeTasks.TaskHandler taskHandler = new OnTimeTasks.TaskHandler();

Now, to create an OnTime Task, we have to create an OnTimeTasks.Task object, set our values, and then call the taskHandler.AddTask(Guid SecurityToken, OnTimeTasks.Task) method (FYI - OnTimeTasks is what I called my Web Reference to the OnTime Task Service), let's look at some sample code;

OnTimeTasks otTask = new OnTimeTasks.Task(); otTask.Name = task.Name; // sets the OnTime Task Name to the Project Task Name onTask.StartDate = (DateTime)task.Start; otTask.DueDate = (DateTime)task.Finish; otTask.Notes = task.Notes; // 60 minutes, 8 hours in a day int days = (int)task.Duration / 60 / 8; otTask.EstimatedDuration = days; // Days (select * from OnTimeDB..TimeUnitTypes) otTask.DurationUnitTypeId = 1; otTask.ProjectId = (cbProjects.SelectedItem as OnTimeProject).ProjectId; otTask.TaskId = taskHandler.AddTask(otTask);

Ok, most of that should be fairly obvious, but the stuff toward the end might not be, the EstimationDuration and DurationUnitTypeId are probably the two most obscure properties were going to work with. The EstimatedDuration property stores a System.Int32 which represents the number of Minutes that the task is estimated to take, however, in OnTime we want to display this as a much smaller number, since presumably we'll spend much more then a few minutes on a single task (remember, MS Project is for setting up the 'Big Picture'). The DurationUnitTypeId is another System.Int32, whose value needs to match a value from the TimeUnitTypes table in the OnTime Database. The SQL Query needed to look at this tables data is provided in the preceeding comment. Once you've found the value for the 'Days' type, put it in the DurationUnitTypeId.

After we set all our of Task values, and have added the Task into OnTime, we can switch over to our favorite OnTime Client (Web, Windows or VS.NET) and Refresh our view and your Task(s) should now be present.

Now, your probably thinking to yourself, "What good is this if I can't go back?". Your right, this tool is fairly useless, as it is now, because all it does is convert an MS Project to an OnTime Project -- but, with little work, you can have a completely customized Synchronization Tool written in a matter of hours. Why didn't I include this ability in the sample? Well, it's a tad beyond the scope of a "sample" for one, but mainly because such a tool would need to be tailored to your specific needs and usage of both applications and there is no hard-set standard for this, so I simply omitted that functionality.

In short though, if you want to introduce tasks into Microsoft Project from OnTime, you can more or less just completely flip the logic used in this sample, and create tasks in Project from tasks in OnTime -- you can even, using Custom Fields to store meta-data (OnTime TaskId and Project TaskId) perform synchronization, so that your Project Manager can quickly say "Sychronize" from a pre-defined Macro which launches a Shell (VBA, gotta love to hate it ... I mean, hate to love it ... err ... its there, just use it ;p) that executes your custom synchronization app -- an example VBA macro would be:

Sub SynchronizeOnTime() Dim i as Double i = Shell("path\to\your\exe" & " " & ActiveProject.Path & "\" & ActiveProject.Name, vbNormalFocus) End Sub

Which could easily launch your tool and pass the current Projects File path to it, so that a synchronization could be performed -- storing additional meta-data in your Project's Properties using Custom Fields, you can determine the OnTime project to lookup, and the Tasks to keep in sync --

For the complete source to this example, please goto the download page.
To discuss this sample, please refer to this forum thread.

OnTime 2007, Outlook 2007, Tasks and your PDA ...

David Higgins — Thu, 19 Apr 2007 22:10:00 GMT

As the newest member of the Axosoft Team, I've spent quite a good deal of time getting acquainted with the OnTime Product Suite. I've come to find that I'm totally digging the OnTime SDK, and I thought that one of my first OnTime SDK projects should be something that everyone's been asking for ... so, I hope I've accomplished at least one of my goals for the day.

I know, everyone loves their screenshots, so I won't hold you up from your eye-candy;

Tasks in OnTime, how ... Normal!

Tasks from OnTime ... in Outlook?!

And again, just cause it's so cool ...

A Task from OnTime, in a customized Outlook Task Form

A Custom Form Region in an Outlook 2007 Task Form, with a Lady Bug Icon!

Editing the Outlook version of the Task ... wonder what happens to the OnTime version?

Oh, nice ... thats convenient!

NOTE: The items in Outlook are 'tagged' with a custom User Property, the only thing this sample relies on to match an OnTime Task to an Outlook Task is this custom property which stores the OnTime TaskId. This means you can literally changed anything, and as long as you account for it in the 'behind the scenes' code, it'll update -- including the Subject/Name of the task itself!

What if I edit it in OnTime though?

Hey ... that's actually pretty cool!

Now that the eye candies over, and I've got your attention ... I wanted to tell you about my cool Geek Marketing idea ...

<plug>
Since I can't officially make contributions to the contest, I figured I'd toss an idea in a blog post and mask it under the guise of a really cool thing you can do with the OnTime SDK, complete with Photoshoped screenshots and all.

So ... my idea is ...
</plug>

Err, ok ... ok, already... you got me ... the screenshots are REAL! For the impatient, you can jump right to the download link, and for those who like to read the nitty gritty details ...

Requirements:

Visual Studio 2005
Visual Studio Tools for Office 2005 Second Edition
Outlook 2007
OnTime Client
OnTime SDK

Time Invested: 12 work hours (8 hours research, 4 hours code)

I'd also like to note that my knowledge of the OnTime SDK prior to starting this was limited, and my knowledge of VSTO was completely nil -- I spent a good day researching the possibilities and experimenting with different ways to modify Outlook, and the following day I came in and wrote this example (got it done before lunch!)

The Basics:
First, we create a new Outlook 2007 Addin Project with VSTO 2005 SE, and then we add a Web Reference to the OnTime SDK Task Service. We create a custom Form Region in Outlook 2007 and save it to Disk, add the Form Region to our projects Resources, and then write the wrapper code that loads the Form Region for OnTime Tasks in Outlook. We also write some simple 'get all tasks, compare them to current outlook tasks, create or update as necessary' code, and viola ... we're done.

Ok ... sorry, I know thats not as detailed as some people would like it to be, but the amount of code and steps involved in creating an Outlook 2007 Addin is a bit beyond the scope of a single Blog post, so you'll just have to download the Sample Code and check it out.

For those of you who may have specific questions about this sample, please feel free to post them in the following forum thread.

Network Deployment of OnTime for Windows

David Higgins — Wed, 28 Mar 2007 22:19:00 GMT

Not quite sure how I wound up getting all these questions, but I've been asked a few times recently how one might go about performing an "Unattended Installation" or a "Group Policy Network Deployment" for OnTime Windows, so I spent a few hours this afternoon looking into it.

I recently posted an FAQ on this subject, but I felt I wasn't being technical enough, and here's what I came up with:


Set wshShell = CreateObject("WScript.Shell")
Set fso = CreateObject("Scripting.FileSystemObject")
isUpgrade = True ' Are we performing an Upgrade?
tempDir = wshShell.ExpandEnvironmentStrings("%TEMP%")
tempPath = tempDir & "\OnTimeInstaller.exe"
installerPath = "\\server\share\path\OnTime2007WindowsSetup.exe"
installPath = "C:\Program Files\Axosoft\OnTime 2007\"
configPath = "C:\TEMP\OnTime.config"
currentUserName = wshShell.ExpandEnvironmentStrings("%USERNAME%")
userConfigPath = "C:\Documents and Settings\" & currentUserName & _
                 "\Local Settings\Application Data\Axosoft\OnTime Windows\7.0\"
' ARE WE UPGRADING, IF SO, UNINSTALL
If(isUpgrade) Then
	If(fso.FileExists(installPath & "OnTime Windows\Uninstall.exe")) Then 
		wshShell.Run """" & installPath & "OnTime Windows\Uninstall.exe "" /S _?=" & _ 
                             installPath & "OnTime Windows", 10, True
		
		' The uninstaller returns a bit -too- quickly, we have to wait
		WScript.Sleep 4000
		fso.DeleteFile installpath & "OnTime Windows\Uninstall.exe"
		fso.DeleteFolder installPath & "OnTime Windows"
	End If
End If
' CHECK IF ONTIME IS ALREADY INSTALLED
' THIS CHECK IS ERROR PRONE!
If(Not fso.FolderExists(installPath & "OnTime Windows")) Then
	If(Not fso.FileExists(installerPath)) Then
		MsgBox "BAD BAD BAD"
	Else
		fso.CopyFile installerPath, tempPath, True
		wshShell.Run tempPath & " /S /D=" & installPath, 10, True
	End If
End If
' CHECK IF OnTime.config exists for User
If(Not fso.FileExists(userConfigPath & "OnTime.config")) Then
	If(Not fso.FolderExists(userConfigPath)) Then
		p1 = fso.GetParentFolderName(userConfigPath)
		p2 = fso.GetParentFolderName(p1)
		if(Not fso.FolderExists(p2)) Then fso.CreateFolder(p2)
		if(Not fso.FolderExists(p1)) Then fso.CreateFolder(p1)
		if(Not fso.FolderExists(userConfigPath)) Then fso.CreateFolder(userConfigPath)
	End If
	fso.CopyFile configPath, userConfigPath
End If

Basically, the above code would reside in a .VBS file, and would be executed by either WScript.exe or CScript.exe during the User Login process --

The code is an example, and should be treated as such -- most of the code blocks are reusable in actual production scripts, but the entire script as a whole is not production ready.

A quick walk-thru of the code shows that we first initialize some variables, which can be stored anywhere, or hard-coded like the example script has them, we then have an 'isUpgrade' flag, which we check in the first 'block', and if true, we run the OnTime Windows Uninstaller, and then delete the Uninstaller and the OnTime Windows directory (this will leave the 'Axosoft' directory and any other contents -- such as SDK, VS.Net, etc).

We then check to see if the OnTime Windows directory exists, if it does not, we launch the OnTime Windows installer in "silent" mode, and we force the installation path with the "/D" flag -- this ensures that we are installing it in the same place as we uninstalled it from, etc ...

We then copy over a pre-made OnTime.config to the current users App Data for OnTime, building the necessary directory tree, if required.

So, how do we get this "OnTime.config" you ask? To get the "OnTime.config", you'll have to install OnTime for Windows on at least one workstation, launch it, and configure the database connectivity -- from there, you can find the OnTime.config in the Current Users "Local Settings\Application Data\Axosoft\OnTime Windows\7.0" directory tree.

And, for those of you who want to try this, here is some useful information about the installer we use:

OntimeWindowsSetup.exe Parameters:

/S -- Performs a "Silent" installation, preventing the UI from displaying
/D -- Override default Install Directory (ie; /D=C:\New\Path)

Uninstall.exe:

/S    -- Performs a "Silent" uninstallation, preventing the UI from display
_?    -- Override the default Install Directory, also prevents the Installer
       from Copying itself to a temporary location and exiting immediately (useful for "WaitOnReturn")

This form of installation is not officially supported by Axosoft, however, the command-line parameters for the (Un)Installer
are supported.

If you've had a successful network deployment and would like to share your experience, or contribute any reusable code, please contact me and I will add it to this Blog Post.

Thank you,
David Higgins

Free Instant Forum to Community Server Conversion Tool

David Higgins — Fri, 23 Mar 2007 20:43:00 GMT

While working on the Axosoft Community Site, one of my tasks was to convert the existing Instant Forum Users and Posts to Community Server. I was lucky enough to have been able to use the DotText-CS-Converter by Kevin Harder to convert the .Text V0.95 Blog site, but was lacking a tool to do the same for our Instant Forum V3.04 database.

With the lack of a tool, I took a few days and wrote one. I learned quite a bit about the Community Server SDK while working on this tool, and I felt that it would only be fair to provide the tool back to the CS community. I also wanted to take the chance to thank Keyvan Nayyeri, for his CS Dev Guide Series, which proved to be an absolutely invaluable resource to me while developing the Axosoft Community Site, as well as Kevin Harder for his work on the DotText-CS-Converter which inspired this tool.

SO .... without further delays ...

The Instant Forum V3.04 to Community Server 2.1 Converter

The tool is fairly simple, you launch it, fill in the required Database Connection Information, allow the application to Save the settings to the App.config and restart itself, and then just goto the "Convert" tab and click "Start". The entire process is automated, however, it is highly recommended that you test this functionality prior to attempting a Production Server Conversion -- this tool was only tested using the Axosoft Forum Backup (Instant Forum V3.04) against a fresh copy of Community Server V2.1.

And, for some screenshots, cause we all love screenshots ...

Here is the Startup screen, along with the Readme.txt in the background ...

Here is the second config screen, where you enter your Community Server database information:

The "Saving your Config" popup, after you click OK, the Application writes to App.config and Restarts itself ...

After the application restarts, you should be brought back to the second config tab, and your CString field should
be a properly formed ADO.NET Connection String pointing to your Community Server and Instant Forum databases.

Here's the Convert! tab, where all the fun begins ... just Click Start and turn on your favorite
movie or something (conversion time is dependent on User/Post count)

To download the tool, along with source, Click Here!

This is an unsupported tool and by downloading and using this tool you accept all responsibilities and risks involved in using this tool. It is highly recommended that you perform database backups and 'test runs' prior to attempting to run this tool in a production environment. Although Axosoft has given me the opportunity to spend the time to clean this tool up for general usage, Axosoft is not responsible for its contents nor has it been reviewed by anyone at Axosoft in any official capacity.

How We Did it, a Brief Synopsis

David Higgins — Thu, 22 Mar 2007 16:48:00 GMT

First, let me start off by introducing myself, I am one of the newest members of the Axosoft Team, my name is David Higgins. I have been working with Axosoft since early 2007.

I have spent the past few weeks working on the Axosoft Community Site, and the conversion from the previously used .Text (DotText) and Instant Forum applications. I started first with the .Text blog site, as the Community Server website had a freely available conversion program that already existed. Problem here was, it only converted .Text V0.95 into Community Server 1.1 -- so I was left with the task of installing CS 1.1, Converting the Blogs and then upgrading to CS 2.1 and converting the forums.

The forums were where I had to put some real work into the site, as no conversion programs existed for Instant Forum at this point. So I wrote one, put it through a few dry tests, and after being satisfied with the results, performed my first 'full' conversion using a backup of the Instant Forum database. This was a success, but did have a few glitches, I remedied these problems and began working on the 'skin' for Community Server so that we could provide an almost seamless transition between all of the Axosoft websites (Axosoft, Axosoft Store, Axosoft Community).

After many trial and error modifications to the default Community Server skin, I made some fairly good progress and became quite accustomed to the oddities that are Community Server Theming. I wish I could say it was easy, but it was not. The process was very time consuming, and I wound up visiting almost every single Skin file that ships with the default skin for Community Server. After working through this, I began working on the Single-Sign-On system that you can see by using the 'Sign In' or 'Register' options in the top header.

The Single-Sign-On system brought Jonas Bush on board in the Community Server development, and required some interesting modifications to our Customer Portal product as well, not to mention some modifications to the way the Axosoft Store worked. We introduced some new elements, such as the ability to load pages within, what we call, 'windows' as well as the ability to have pages redirect after a PostBack. Jonas did a great job with this, and I'm very pleased with the Single-Sign-On and cross-site navigation that was introduced to all three of the Axosoft Sites.

For now, I won't go into too many technical details about how we pulled this off, I'll reserve those for future posts (which may even include example code, or downloads), and I'll just leave you with this ...

When I first approached Community Server, I was a bit weary about whether or not it would be a successful tool and if we could pull off everything we hoped to with it. After working with it for a mere 4-5 weeks, I am extremely pleased with it and would suggest it to anyone who wanted to build a Community Site, or even a corporate Intranet. The power that Community Server provides is outstanding, and once you get past those first few steps in development, you can develop and deploy new tools, controls and components in literally minutes (of course, depending on the complexity requirements).

-- David Higgins
Axosoft, Developer