Oh yeah, now we have an official name for what was code named “090x”. It is K2 4.5 and, we will have K2 blackpearl 4.5, K2 blackpoint 4.5 and K2 connect for SAP 4.5 entering beta cycles shortly. This release is a major milestone for K2 as the fourth generation K2 technology released in August 2007 now matures into the next level.

One of my favourite features of K2 to look forward to in this release is called the “Inline Functions”. With Inline Functions, one can construct complex rule evaluations very easily without writing code. There is an impressive array of pre-built functions made available. There are things like GetXmlValue() for working with Infopath content, PadLeft() and other string manipulation functions, Conversion functions for type casting and your standard logical functions.

In the screen shots below you will see the inline functions in action:

Inline functions can be called everywhere within a K2 process. Combining them with smart objects will open up interesting scenarios. There is also an API made available for extending these out-of-the-box functions with your own custom goodies.

Sometimes it can be useful to recreate the same situation that you have in a K2 farm elsewhere:

• if you got some troubles in a production environment and you want to investigate on them without corrupting the environment further
• if you want to test an hotfix or upgrade and you want to do that having exactly the same situation that you will find in your final environment
• if you want to stress test a clone of your production environment without interrupting the service

K2 [blackpearl] comes with 14 databases. As far as it concerns processes data, however, only two databases have the main impact:

• K2Server: it is the transactional database used for workflow execution and tasklist retrieval
• K2ServerLog: it is the logging database used for reporting data, smart object and viewflow

While the server is running some dedicated threads move data that’s no more needed for execution from the K2Server to the K2ServerLog database.

In order to move data from one farm to another it is sufficient to replace these two databases in the destination farm with the ones from the source farm (either via detach/attach or backup/restore).

At that point it is enough to run the following T-SQL script in the K2Server database of the destination farm before restarting the K2 server service:

USE [K2Server]

– Setting K2 Server and removing extra entries

DECLARE @HOSTNAME NVARCHAR(20)

DECLARE @LICENSE NVARCHAR(20)

SELECT @LICENSE = [LicenseKey], @HOSTNAME=[HostName] FROM [HostServer].[dbo].[LicenseKeys] WHERE [HostName] = ‘dest farm hostname‘

UPDATE [_Server] set [Name]=@HOSTNAME, [LicenseKey]=@LICENSE WHERE [ID] = 1

DELETE FROM [_Server] WHERE ID > 1

– Update Server Users

DELETE FROM [_ServerUser]

INSERT INTO [_ServerUser] VALUES (‘K2:DENALLIX\Administrator‘, 1,1,1)

INSERT INTO [_ServerUser] VALUES (‘‘K2:DENALLIX\K2Admin‘, 1,1,1)

INSERT INTO [_ServerUser] VALUES (‘‘K2:DENALLIX\K2App‘, 1,1,1)

– Update Settings…

UPDATE [_Setting] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5555′ WHERE [Name] = ‘UMData’

–Update String Tables

UPDATE [_StringTable] SET [Value] = @HOSTNAME

WHERE [Root] = ‘Production’ AND [Name] = ‘Mail Server’

UPDATE [_StringTable] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5555′

WHERE [Root] = ‘Production’ AND [Name] = ‘SmartObject Server’

UPDATE [_StringTable] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5555′

WHERE [Root] = ‘Production’ AND [Name] = ‘ServiceObject Server’

UPDATE [_StringTable] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5555′

WHERE [Root] = ‘Production’ AND [Name] = ‘Category Server’

UPDATE [_StringTable] SET [Value] = ‘http://’ + @HOSTNAME + ‘:8081′

WHERE [Root] = ‘Production’ AND [Name] = ‘Web Service URL’

UPDATE [_StringTable] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5252′

WHERE [Root] = ‘Production’ AND [Name] = ‘Workflow Server’

UPDATE [_StringTable] SET [Value] = ‘Integrated=True;IsPrimaryLogin=True;Authenticate=True;EncryptedPassword=False;Host=’ + @HOSTNAME + ‘;Port=5555′

WHERE [Root] = ‘Production’ AND [Name] = ‘Workflow Management Server’

– ** NOTE – The Actioners might need to be updated with new labels??

–select * from _Actioners

The script updates all the relevant tables… it is only needed to change the hostname and the server users (highlighted) accordingly.

• To use the ViewProcessInstance method of SourceCode.Workflow.Client.Connection to retrieve an xml representation of the process instance flow (it is essentially what the OOB ViewFlow does under the hood)
• To access directly the K2ServerLog database in order to extract the information I needed

Even if the first choice should have been the right one for many reasons:

• Coding over data provided from a documented API should be faster than reading the same data from a partially documented database
• What would happen at my code if K2ServerLog changed due to a K2 hotfix?
• Why do not follow the same path that SourceCode itself followed?

I finally decided for the second one because:

• I saw that accessing K2ServerLog directly performs better than calling K2 server to retrieve the same data
• Accessing K2ServerLog directly instead of calling K2 server doesn’t load K2 server
• The K2ServerLog schema is not changed frequently… the actual one has pretty much the same structure it had in K2.NET 2003
• K2ServerLog tables and schemas are documented in the K2 [blackpearl] official documentation
• K2ServerLog is the logging – not transactional – database, thus accessing it should not disrupt K2 Server execution performances
• I had few time to realize my POC and I knew well the structure of K2ServerLog because I already studied it before for other purposes
• I wanted to try RIA Services in a real scenario… J

I started defining constraints (keys, foreign keys, relationships…) on a copy of K2ServerLog database (K2ServerLog itself comes with no constraints). This would have helped LINQ to SQL to create entities and associations in the appropriate manner. Obviously constraints were only needed for development and were not meant to be used at runtime. What I obtained finally is the following (I extracted below only the part that is relevant for my View Flow):

After that I created a new Silverlight Application and I enabled .NET RIA Services integration:

public _ProcInst Get_ProcInstById(Int32 procInstId)
{
DataLoadOptions loadOptions = new DataLoadOptions();
 
// ProcInst
loadOptions.LoadWith<_ProcInst>(p => p._Proc);
loadOptions.LoadWith<_ProcInst>(p => p._ActInsts);

// Proc
loadOptions.LoadWith<_Proc>(p => p._Acts);
loadOptions.LoadWith<_Proc>(p => p._Lines);

// Act
loadOptions.LoadWith<_Act>(a => a._Events);

// Line
loadOptions.LoadWith<_Line>(l => l._Act);
loadOptions.LoadWith<_Line>(l => l._Act1);
loadOptions.LoadWith<_Line>(l => l._LineInsts);

this.Context.LoadOptions = loadOptions;

_ProcInst procInst = (from o in Context._ProcInsts
where o.ID == procInstId
select o).First();

return procInst;

I decorated with the Include attribute the same properties in the appropriate metadata classes:

internal sealed class _LineMetadata
{
// Metadata classes are not meant to be instantiated.
private _LineMetadata()
{
}

[Include]
public _Act _Act;

[Include]
public _Act _Act1;

[Include]
public EntitySet<_LineInst> _LineInsts;

And that’s it; I was ready to code in Silverlight!!!

And that’s the result… I know it’s still not too rich but I haven’t spent too much time playing with effects:

Transaction Processing

The technology responsible for making the exchange balanced and predictable is called transaction processing. Transactions ensure that data-oriented resources are not permanently updated unless all operations within the transactional unit complete successfully. By combining a set of related operations into a unit that either completely succeeds or completely fails, you can simplify error recovery and make your application more reliable.
A transaction is a set of related tasks that either succeed or fail as a unit. In transaction processing terminology, the transaction either commits or aborts. For a transaction to commit, all participants must guarantee that any change to data will be permanent. Changes must persist despite system crashes or other unforeseen events. If even a single participant fails to make this guarantee, the entire transaction fails. All changes to data within the scope of the transaction are rolled back to a specific set point.Automatic transaction processing is a service provided by COM+ that enables you to configure a class at design time to participate in a transaction at run time. To use this service, the class must derive directly or indirectly from the System.EnterpriseServices.ServicedComponent class.

Writing Serviced Components

A serviced component is the mechanism that enables COM+ services to be available to .NET Framework classes. You can modify any Common Language Specification (CLS)–compliant class to use COM+ services. The System.EnterpriseServices namespace provides custom attributes and classes for accessing these services from managed code.
If you are new to writing serviced components take a look here.
If you are new to transaction isolation level in COM+ take a look here.

Enable Root Transactions in K2 [blackpearl] Server Events

In order to make a K2 Server Event working in a transactional manner you need to configure this behaviour both at the Activity and Event level. It is as simple as checking two check boxes in the General Properties Wizard for the Activity and one of the contained Server Events:

There is only a rule to bear in mind: a transactional Activity can contain only a single Server Event marked as transactional. This basically means that the transaction context does not flow across different Server Events within the same Activity. Missing this requirement may result in unexpected behaviour (like the process halting in running state indefinitely).
What happens behind is that K2 [blackpearl] registers on the fly a transactional serviced component (K2STXH). This component is used this component as the root of the transaction when executing via reflection the code contained within the transactional Server Event.
The aforementioned K2 transactional server component presents the following characteristics:

• TransactionOption is RequiredNew: it means that a new transaction is created (the component is the root of the transaction)
• IsolationLevel is ReadCommitted

 

Writing Serviced Components for K2 [blackpearl]

You can write transactional serviced components and enlist them in a transaction originated from the K2 Server Event.
In order to allow your serviced components to be enlisted in a transaction started from a K2 [blackpearl] Server Event you have to:

• Configure the TransactionOption as Required or, at least, Supported. This is because the serviced component that K2 uses as the root of the transaction has its transaction option configured as RequiredNew.Marking your serviced components as RequiredNew will generate a new transaction while marking them as NotSupported will make them not to take part to the transaction
• You cannot configure them with a transaction isolation level higher than ReadCommitted. This is because the serviced component that K2 uses as the root of the transaction has its isolation level configured as ReadCommitted

 

Chris “community man” Geier from K2 has released a video on Kerberos – the necessary evil that we all need to befriend – check this out here – very useful.

The next update to K2 blackpearl is in beta now. This release will bring some key new features such as

> The new Silverlight-based Process Designer for SharePoint
> Inline functions, which allow for calculation, boolean logic
and text manipulation with no code
> An update to the API set for process instance management

you can get it from the K2 customer portal now.

I have been playing around with the recently released SP2 for Sharepoint 2007 with K2. This was mainly to check for any compatibility issues. I also wanted to look at the newly updated K2 blackpoint installer and the diag tools

My experience upgrading a K2 807 enabled Sharepoint server to SP2 went without issues. K2 continued to function well.

My testing was done on a fairly simple MOSS VM. I have not done any performance benchmarks. I am also interested in the Forms Server enhancements made for MOSS http://support.microsoft.com/kb/953334 But, that will be for another blog post.

My test run also covered K2 blackpoint (latest installer). I think the software works fine with SP2. BTW, The most awaited K2 update code named ‘090x’ will officially support Sharepoint SP2 along with aligning with 2008 wave.

The updated blackpoint installer (note: this is not an upgrade to existing blackpoint environments) is great – its diagtools are brilliant, helping you verify the install, settings, permissions, etc – a very valuable tool. It checks for  and fix issues reported.

If you find any issues with upgrading to SP2 or installing K2 on an SP2 environment please log a support ticket with K2 or go to Forums on k2underground.com

UPDATE: There is a hotfix available for an issue that has been found when using Sharepoint integration tasks in K2 processes. Check this out - KB000451 – Hotfix: After installing MOSS SP2, SharePoint Integration tasks are not created for the second and subsequent client events.

There has been a number KBs made available since the release of the update 370. Take a look these and apply the relevant fixes if you have the issues mentioned occurring in your environment. There are also a few FYI type KBs which I have not included here. For a full list visit the K2 customer portal.

KB000375 – Hotfix: Event Instances Report in the Process Overview Report shows events that belong to another activity.
When using the Activity Instance Report or the Process Overview Report in the Out of Box Reports in K2 Workspace the activities reported on are incorrect and reflect the data of a different activity or event.

KB000376 – Hotfix: Searching for users in K2 Workspace returns users with the wrong domain prefix.
When using Multidomains in the same forest, occasionally the incorrect domain prefix is returned when searching for users in K2 Workspace.

KB000378 – Hotfix: Activity Instances Destinations Report in the Process Overview Report shows incorrect activity name
When using the Activity Instances Destinations Report in the Process Overview Report of the Out of Box Reports in K2 Workspace, the data summary may incorrectly reflect the activity name for a different activity in the process.

KB000382 – Known Issue: An exception occurs when completing an asynchronous server event by calling the Update or Finish method from an external application.
An exception occurs when completing an asynchronous server event by calling the Finish method from an external application.

KB000380 – Hotfix: The value of the “AllocatedUser” property (on an OpenWorkListItem method call), is not returned correctly
There is a known issue related to the K2 blackpearl 0807 update KB000350 and KB000370 that when the OpenWorklistItem method is invoked, the WorklistItem’s AllocatedUser property has a null value

KB000383 – Known Issue: Loading a record with a SmartObject date property that is empty causes a “Specified cast is not valid” error
When using the SmartObject Event Wizard to replicate datafields and one of the SmartObject properties is of Date/Time type, a “cast” error will occur if this source SmartObject property is left empty.

KB000384 – Hotfix: An exception occurs when completing an asynchronous server event by calling the Update or Finish method from an external application.
An exception occurs when completing an asynchronous server event by calling the Update or Finish method from an external application.

KB000360 – K2 connect: How to cache credentials for K2 connect for SAP Security Labels
K2 connect for SAP requires that a second set of user credentials be cached in association with the user’s primary identity. This article provides high level technical information on the options available to the developer and how they can be implemented along with a technical discussion of how the authentication procedure works for K2 connect for SAP.

KB000385 – Hotfix: Loading a record with a SmartObject date property that is empty causes a “Specified cast is not valid” error

KB000387 – SSO Error after K2 blackpearl Configuration Manager is run
Error occurs after re running the K2 blackpearl Configuration Manager and user authenticates using SSO

KB000388 – Hotfix: Shared Activity Level Datafields will revert to default values when the client event is instantiated

KB000396 – Hotfix: K2 Migration Utility becomes unresponsive on “List InfoPath Documents” page
While running the K2 Environment Migration Utlility the application encounters a problem and stops responding while attempting to retrieve the List of InfoPath Documents. No error message is displayed to the user.

KB000398 – Known Issue: K2 Designer for Visual Studio is unable to compile a project that contains a K2.net 2003 Artifact(s)
When K2.net 2003 artifacts are imported or used in a K2 designer for Visual Studio project and later the user attempts to deploy the process, K2 designer for Visual Studio is unable to compile the K2.net 2003 Artifacts.

KB000397 – Hotfix: Release Worklist Item Using the K2 blackpearl API does not work as expected
When the Administrator, or user with the appropriate rights attempts to release a worklist item when the destination was a user group using the SourceCode.Workflow.Management.WorkflowManagementServer.ReleaseWorklistItem, an exception occurs stating that the worklist item is not found

KB000389 – Hotfix: Object Reference error when an Escalation on an Activity is moved to a new process version by Error Repair
An Object Reference error may occur after using the Error Repair tool on a process that has escalations
configured for activities within the process. Once the Error Repair tool has moved the the process instance
in error onto a new version of the process, the activity escalations in the process instance and the new
process definition do not match.

KB000400 – Hotfix: K2 Designer for Visual Studio is unable to compile a project that contains a K2.net 2003 Artifact(s)
When K2.net 2003 artifacts are imported or used in a K2 designer for Visual Studio project and later the user attempts to deploy the process, K2 designer for Visual Studio is unable to compile the K2.net 2003 Artifacts.

KB000402 – Hotfix: Error occurs when opening an InfoPath Client Event.
When using InfoPath Workflow integration and Forms Services it will not open the InfoPath client events if the user opening them does not have at least contributor rights.

KB000390 – Hotfix: The returned XML for a SharePoint user(s) is not fully formed if they have minimal permissions available when working within SharePoint.

KB000407 – Hotfix: Issue with Notification Event Designer.
If a notification is edited that contains Worklist Item URL data fields. The notification e-mail will be sent when the notification event is fired but the Worklist Item URL will not populate correctly with the runtime data. Re-opening the edited notification in the Notification Event Designer shows a blank e-mail body.

KB000393 – Hotfix: Intermittent error in SharePoint when moving documents to a Records Center
Intermittent errors may occur on the SharePoint Web Frontend when a K2 process attempts to move a
document to the SharePoint Records Center. These errors can, however, be successfully repaired
by re-trying them from the Management Console.

KB000411 – Known Issue: Custom Reporting Services component not visible
After installing K2 blackpoint 0902 (4.9040.1.0) the SOURCECODE data source in Visual Studio required for designing custom reports is missing.

KB000412 – Hotfix: K2.net 2003 ServerItem Not Found post Migration
After migrating from K2.net 2003, processes which included a Asynchronous Server events throw an error

KB000413 – Hotfix: Error occurs when the “Active Directory Service 2″ is invoked with 1500 or more process instances.
There is a known issue related to the K2 blackpearl 0807 update KB000370 that when the “Active Directory Service 2″ is invoked with 1500 or more process instances it will throw an “Out Of Memory” error. .

KB000410 – Workaround: K2 Connect for SAP – NLB Cluster Workaround Configuration
Existing users of K2 connect for SAP may want to extend the capabilities of their envionment by clustering the K2 connect servers. Since this functionality is not fully supported in the current release, a workaround has been devised to facilitate this.

KB000404 – Hotfix: Multiple users opening connections that call the Impersonate method increase execution times with every new concurrent connection
When multiple users open connections that use the Impersonate method on a K2 Connection, the execution times increase with every new concurrent connection.

KB000414 – Hotfix: InOut Parameters not returned correctly for a K2 connect custom method
A K2 connect ServiceObject which includes a custom method, does not handle InOut Mappings correctly

KB000408 – Hotfix: When using IPC processes and data from the child process should be returned to the parent process, the data is not retrieved.
When using IPC processes and sending and/or receiving information between processes, errors may occur intermittently due to data not being send through from the child process back to the parent process. Various memory, performance and threading enhancements have been made to the K2 Server, IPC’s and Escalations, which include:
- Memory enhancements made to the K2Server to ensure that only relevant data is stored in the ProcessInstance state
- Performance and threading enhancements made to IPC’s that would improve memory consumption
- Performance and memory enhancements made to Escalations

KB000386 – Hotfix: Unable to retrieve column data from a system library in SharePoint using Process Event Integration
The error message detailed below occurs in conjunction with the SharePoint Process Integration Wizard at run time. The individual checks a page back in from a SharePoint document library either an Item Checkin or an Item Update action (This error may persist for other event actions).  As soon as the action is attempted, the process goes into error.

KB000415 – Hotfix: Error received when trying to activate the K2 Workflow Integration Content Type feature.
When installing K2 blackpoint 0902 (4.9040.1.0) using WSS an error occurs when trying to activate the K2 Features.

KB000377 – Hotfix: Browser Enabled forms render as XML when “InfoPath, Web browser if InfoPath not available” is selected
When using InfoPath Forms Services and selecting the option “InfoPath, Web browser when InfoPath is not available”,
the form is rendered as XML when opening the action in K2 Workspace and neither K2 for Visual Studio nor InfoPath is available.

KB000381 – Hotfix: Duplicated destination user in Activity Instance Destination Report
There is a known issue related to the K2 blackpearl 0807 update KB000370 that when there are two parallel activities (Activity B and Activity C), both with a single destination user and both with Client Events where only Activity B is instantiated (because the line rule to Activity C is invalid (1=0)) then and error occurs in the Activity Instance Destinations report from Activity B which incorrectly shows two lines with the same user.

Process design in K2 is simple. On the surface the process map can appear as pretty basic. It does not really have many visual shapes to play with. I call K2 process map as a pure boxes and lines diagram. It has boxes which are called activities that are connected to each other via lines.

What goes inside the boxes and behind the lines is what interesting. K2 process map only has one pre-defined activity called the “Start” Activity. This some times causes a bit of confusion. Firstly there is no matching “End” Activity in K2 as the process engine determines when a process instance ends. Also to reach the Start activity inside the process a process instance should have already been started

Some process templates provide options to specify how a process can be started – namely sharepoint and infopath templates. But, any process map, regardless of how its start options are configured can be programatically started. This is what cool about K2. The options are endless.

Over the past several months I have been working closely with the team at K2 to develop workflow solutions with K2 blackpearl – and have found myself dipping into the excellent (and only) book on the product so far – “Professional K2 blackpearl“, published by Wrox Press.

What is “K2 blackpearl”?

K2 blackpearl seems to go by many names – depending on who you talk to it’s either a workflow solution, or a business process management solution. To further complicate matters, some people will claim that “workflow” and “business process” are two completely different things.

In simple terms, blackpearl takes over the job of “making things happen” in and around the various users and servers within an organisation – by delivering tasks to users, acting on the results of those tasks, kicking off external processes and even running code itself. All of this is executed according to rules, logic and scheduling designed with the suite of tools accompanying the product. If implemented properly, users will never be aware of the technical gymnastics blackpearl performs behind the scenes.

A Lot to Learn

As you might expect from a product set designed to interface with Microsoft SharePoint, web services, Infopath, Office, bespoke .NET applications, and even the mighty SAP, K2 blackpearl is an enormous product to learn and develop for – and you can’t help feeling a sense of awe that a company so much smaller than Microsoft attempted (and succeeded) in pulling off such a feat.

The problem therefore becomes similar to that of the SharePoint developer – where on earth do you start? Luckily, K2 provide excellent training through their training courses, and also work closely with partners to flatten the learning curve a little. Until very recently however there was very little in the way of printed documentation.

K2 blackpearl – the Book

The book we had all heard mention of for many months finally went to print earlier this year, and what a book it is. The first afternoon it arrived in the office I grabbed it and had a look through during a coffee break. A manager asked what I thought of it…

This is the book that K2 2003 never had – it’s excellent.

Quite apart from the expected tour of features and functionality, the K2 blackpearl book comprehensively details the various server configurations you may see in the real world, and gives copious advice on specification for that infrastructure. It’s more a compilation of shared knowledge than a textbook – and this is reflected by the number of authors who contributed to it.

The Community

One of the surprises when learning about K2 is the direction the company has taking to connect with customers. They are one of the few organisations I have seen really get social networking – they host open developer forums, and actively participate in emerging networks such as Twitter. It’s a pleasant surprise to see the K2 consultants, developers and support engineers openly engaging with the community.

In many ways K2 (or “SourceCode”, as they are perhaps more correctly termed) remind me of a young Apple. They have a great product, and their people are talented, driven, and above all enthusiastic about the product set they are building. I’ll close by returning to the earlier observation – you can’t help but admire them for the breadth and scope of their vision – and the fact that they are pulling it off.

For the last few days I have been working alongside the original developer of the Case Accelerator from K2 – Igor Jericevich – doing some knowledge transfer and tutoring on the codebase and development concepts. I thought it might be interesting to share what the Case Accelerator is, and how it might be of use to you.

What is the K2 Case Accelerator

In loose terms, the Case Accelerator is a set of pre-built assemblies and Smart Objects that give you a huge head-start when developing case management systems with K2 blackpearl. It maps out a set of approaches to solving common case scenarios;

• Managing over-arching parent processes with unstructured child processes
• Managing structured and unstructured data simultaneously
• Provision for key performance indicators on overall case status
• Provision for a “core” framework around which you can build application specific case solutions.

One of the most impressive aspects of the code-base is the way the case “context” can be extended (via generics) to enumerate application specific objects and properties. The hard work has already been done for you – allowing simple inheritance and specification of interfaces to write “case enabled” classes.

What Benefit is the Case Accelerator

Unless you have developed case solutions in the past, it’s difficult to quantify in meaningful terms just what the guys at K2 have achieved with the Case Accelerator.

One of the classic problems faced when building enterprise workflow solutions is the need to provide common functionality across the enterprise (typically common interface designs), and to extend uniquely within specific areas of the business. The Case Accelerator neatly solves this by de-coupling parent and child processes – allowing both structured child processes to be fired as well as ad-hoc child processes.

A larger business process may have many smaller processes within it – some of them may happen at specific points during the wider process (an approval process, for example), whereas other child processes may be requested at any time (a review, for example). Solving both has traditionally meant spaghetti parallel process designs.

In coming months I will share some of the specific methods and techniques employed by the Case Accelerator with the wider community. I think the tool set is going to make process driven case management a much more realistic proposition to implement than it was even two years ago (over which time incidentally I built a HUGE system which suffered from all the technical problems I have outlined above).

Fellow insider Jason wrote about his experience migrating K2.net 2003 VB based processes to K2 blackpearl. Take a look at http://www.k2underground.com/blogs/jmonty/archive/2009/04/02/migrating-to-k2-blackpearl-vb-net-support-in-k2-blackpearl-processes.aspx

While talking to one of the developers from K2 today, I discovered a couple of things I hadn’t previously realised about K2 blackpoint that will have profound implications for anybody trying to use it as a cheaper substitute for K2 blackpearl…

A Reduced K2 client API

The K2 blackpoint API is restricted – you cannot action worklist items through it.

This is huge. When I started looking at K2 blackpoint, and wondered what it was capable of doing, I immediately started thinking outside the box – about how the integrations around it could be used to extend it’s functionality.

I’ve written in a previous post about the existence of the SharePoint Workflow Integration – and the door it opens up to write bespoke ASP.NET forms (with the idea of also replacing the default Worklist webpart to intelligently open SharePoint workflow tasks for you in this case – essentially doing an end-run around K2 blackpoint to provide ASP.NET forms).

If ASP.NET forms cannot use the K2 client API to action worklist items, the entire proposition becomes much more difficult.

No Registration of Bespoke SmartObject Servers

This was unexpected, and I have still not confirmed it for myself. Apparently you cannot register your own SmartObject servers with K2 blackpoint. While this sounds like a huge spanner to throw in, it’s not actually that bad – web service integration still exists.

Thinking about it, custom SmartObject Server deployment would be difficult with K2 blackpoint anyway – if you recall that SmartObjects are really two parts (a server and an interface), there is no way of specifying the interface in blackpoint.

And a Pleasant Surprise…

During the day I was reminded of the SharePoint SmartObject integration built into blackpoint – easily overlooked (I had forgotten all about it) – that allows you to create a SmartObject describing everything in a site. Suddenly the toolbox I had been thinking about building (to return the number of items in a list, or the Nth item) isn’t needed at all.

For the next several months I will be working almost exclusively with K2 blackpearl – but gaining a grounding in K2 blackpoint over the last few weeks has been useful to re-inforce the concept of not re-creating the wheel.

It’s tempting when working in Visual Studio to always go to the code, and invent your way out of everywhere, rather than think about how you got somewhere in the first place. Developing solutions with K2 blackpoint forces you to always consider what you’re doing, and how you’re doing it.

K2 has a feature named viewflow – this is a visual rendering of a process instance – which allows authorised users to visualise the flow of a business process in real time. It is a colour coded map that gives indication as to where the current process instance is at, where it came from and the path it could take next. Clicking on the flow you can access reports that gives you more info on the process.

The viewflow control comes with K2 is a .NET component that is installed on the client machines. This control is supplied with XML data that represents the process state at real time. The control can be linked to any process instance as long as the instance ID is known. This can be very useful to provide URL links to processes that are run by users. In a Sharepoint environment for example we could embed this link in a list that can hold meta data about a purchase order raised by a user.

One issue with viewflow is that the process diagram in its entirety is displayed. In some cases this is not ideal.

The viewflow control is installed by the .aspx page hosted under the K2 workspace. There is a .cab file found under the K2 install directory, You can extract the ViewFlow control installer from here (C:\Program Files\K2 blackpearl\WorkSpace\Site\TaskListControl\K2ViewflowDeployer.cab) which houses the .MSI for deploying the viewflow control.

Question: How one might push the control to all client desktops in a SOE environment? If you simply copy this msi and create a logoff script for your users via group policy in AD within a week most of your users will have this control ready to go. My friend Marco told me about this. Recently I used this info to help another consultant. There you go Mate, I have paid it forward.

Did you know there is a tool that ships with K2 for configuring and testing your service objects and smart objects? This tool called the “SmartObject Service Tester” is found in K2 blackpearlservice broker folder of your K2 server install directory.

On launch it lists your service objects and smart objects found on the host server.

You can register service types and instances from this tool as well. (some of this functionality is similar to what provided in the brokermanagement.exe and via the K2 workspace management console)

You can pick a service object and use the tool to generate a smartobject out of it for you.

This generates the .sodx and provides an editor interface to manipulate this SmO definition

In here you can change the names, category, edit/delete properties and methods and the either publish your SmO or generate the .sodx.

You can also execute the SmO and run tests with this tool. There is more to this tool, enjoy playing around.

I have been working with a client since December’08 (on and off) implementing an end to end K2/Sharepoint/Formservices solution. One aspect of the K2 process application we have been building is to notify various parties involved about whats going on and what they have to do, etc via…surprise surprise… emails

We looked at out-of-the-box client event notifications, Mail events in process and the event bus. We have chosen to go with the event bus for a number of reasons and I think this highlights the value of this component of the K2 platform:
1) We have about 26 different notifications
2) Business wanted to manage the content of these emails
3) The content will have a high degree of change in formatting, wording and data values from the process
4) No need to guarantee delivery of these emails, any error in sending does not have to affect the process instances

We wanted to rapidly build this application using Infopath formservices and outsourcing the email bits to client stake holders would free up the developers from the pain of getting those email notifications right. The notification events were created in reaction to some ‘proxy’ server events in the process. By giving business users the ability to change the email bits without a re-deploy means, less testing and immediate effect on process instances in motion – all are welcomed side effects.

The current inability to port email notifications from one environment to another automatically, works to our advantage to get the K2 workspace to be used in production directly by users sort out the emails there. We noted the lack of drag-n-drop ability for the XMLDatafields in the notification event designer UI and lack of file attachments but have managed to work around them. We created process datafields for some of these data values and made sure that is reflected by some server events. We also do some of the file attachment emails from within the process.

Got a few things to share re: out of the box task notifications. You can modify the message by updating the email template. but, be careful! You must ensure you include the tag [UrlWithSN] somewhere in there (I put it behind an html comment block) as otherwise you will get an exception when trying to deploy the notification event. see my response to this post on K2underground. Also you need to update the from email address used by K2 by updating the config files found under hostserverbin directory on the server install directory. (Search for string “K2@system.local”)

By default K2 uses AD for its authentication and authorisation mechanisms. It also ships with a Security provider which allows you to use a database as an alternative user information provider. You can also build your own custom Security Provider which can be plugged into K2.

The steps to achieve this involves writing a DLL implementing the IHostableSecurityProvider interface (SourceCode.HostServerInterfaces.dll in K2 install directory) and registering it with K2. You will need to update K2 database table entries and also need to sign and copy the DLL into the K2 install directory.

You will implement the methods required to work with your users and groups. K2 will use your code for authentication and authorisation.

This article has some sample code

Please check out these KBs: http://kb.k2workflow.com/articles/kb000331.aspx, http://kb.k2workflow.com/articles/kb000186.aspx

Check this KB written for K2.net 2003 re: Scalability, Clustering and Sizing. It talks about Clustering in good detail, A very good read.

Checkout this blackmarket project -  Outlook 2007 Tasks add-in. It allows you to pull your K2 tasks into Outlook and manage them inside Outlook.

Here’s a post by Bob on kicking off child process instances to process a dynamic set of requests. Good trick to know.

Recently I took part in a PoC activity with a prospect where I was asked to demonstrate how a user might complete a task assigned to them by simply emailing K2. Ever since I came across the “email enabled list” functionality of sharepoint I had a simple solution proposed to many of my clients. This is the first time though I had to do it. So, I rolled up my sleeves and got on to the job.

Email interaction can be used to kick-off a process instance or to complete a human or system task within K2. Email also can be sent out as notifications to users and systems such as phonenumber@smsgateway.com or messengerbot@messagejey.com, etc to provide really fancy functionality.

I launched my VM and started setting up mail and then sharepoint to email enable a list. I tested the functionality by sending email to the hardcoded email address (actionk2@company.com) and watched documents get created and attachments saved in to the document library I have created. Then I deployed a sharepoint events process using K2 which was tied to that email enabled doclib. All this process was doing is once kicked off by the Item added event, it was picking up the serial number of the task, user name of the actioner and the action they have chose from that email. Then a server event impersonated the user, opened the worklist item and actioned it off!

K2 partner iTechnology builds forms capabilities for K2. check this out

For those who may have used AchieveForms with K2.net 2003 this forms accelerator would be very familiar. There is a forms event which allows you to build very functional forms very quickly with zero code. Screenshots below are taken from the video presentation hosted by inobits (a K2 partner who is the exclusive distributor for iTechnology forms accelerator for K2 in USA)