K2 Underground

Using K2 connect 4.6.5 deserialize/serialize functionality in K2 smartforms

johnny — Thu, 06 Jun 2013 07:30:00 GMT

K2 connect 4.6.5 (KB000750) just got released recently. Apart from the designer support for VS2012 and the ability to directly upgrade from existing 4.5 installs, one of the exciting new features is the ability to work with SAP structures and collections using SmartObjects. This is pretty nifty as this basically allows you to use K2 smartforms to insert or display complex SAP data types. So how does this work? Now there is a KB article that shows you how to serialize and de-serialize a structure...(read more)

K2 smartform Tips: Using the Transfer Data Rule

johnny — Mon, 20 May 2013 06:40:00 GMT

Author: Nuqman Baktiar In this series of tips and tricks, we will showcase how transferring data using the Transfer Data rule to pass a value from one view to the other. Question: How do I transfer a value from one view to the other with K2 smartforms? Answer: STEP 1 Lets start by creating 2 views, ViewA and ViewB , add a textbox and a button for both views. ViewA ViewB In ViewA we will add a rule to display a subview when the button is clicked. This can be done easily from Rules page. Add the rule...(read more)

K2 smartforms 1.0.2 is out!

johnny — Fri, 10 May 2013 18:23:00 GMT

K2 smartforms 1.0.2 has just been released. Don't let the minor number revision fool you. There is a slew of fixes and new features that has been packed into this exciting release. Some highlights: New Content control (works like an iFrame) PDF control (for snapshotting your form and stores it as a PDF file for use later in emails, reports, etc) View parameters (you can know initialize views with just parameters. The rules stay within the view) Numerous performance enhancements on runtime performance...(read more)

Setting up a secondary K2 smartform runtime site for anonymous access

johnny — Tue, 09 Oct 2012 16:18:00 GMT

The default K2 smartforms runtime site uses windows authentication and authenticates to Active Directory. However, it is usually a common scenario where you need to create a form that is targeted for external users that do not use Active Directory credentials. e.g. internet users. This article shows you how to make a secondary K2 smartforms runtime folder used for public facing forms (anonymous users). 1) First make a copy of the K2 SmartForms Runtime folder. I am calling mine K2 SmartForms Runtime...(read more)

Working with Onboarding and K2

johnny — Wed, 03 Oct 2012 04:32:00 GMT

I have been working a bit on onboarding processes and utilizing the Active Directory and Exchange Event Wizards makes this really easy to generate user accounts and mailboxes as part of the K2 process. However, there are two issues I noticed: The AD user is generated using the first name and not the full name There is no option to specify an additional proxy SMTP email address for the user. e.g For a user called John Smith, his default email might be JohnS@denallix.com but you might want to add a...(read more)

Deploying the Silverlight package to users using a GPO

johnny — Thu, 13 Sep 2012 03:24:00 GMT

There are a number of K2 components which leverages off Microsoft Silverlight. The K2 View Flow, K2 designer for SharePoint and the K2 smartform designer utilize Silverlight. So if you decide to expose one or more of these components to end users, they need to install Microsoft Silverlight on their machines first. However in a number of corporate environments, users normally will not be able to directly download components and install them by themselves. So how do we automate this? One of the easy...(read more)

VMWare Workstation Long Shutdowns or odd pauses

johnny — Thu, 30 Aug 2012 03:20:00 GMT

Though this isn't exactly K2 related but we tend to run a lot of test VMs running off VMware workstation. I thought this tip might be useful to pass along as somebody mentioned that they also faced this issue with VMware. However, I tried the following setting and it works pretty well for me. Add the following entries to this config file. It will be in one of these locations. C:\ProgramData\VMware\VMware Workstation\config.ini C:\Documents and Settings\All Users\Application Data\VMware\VMware...(read more)

K2 Tip of the Day : When to use IPCs?

johnny — Fri, 27 Jul 2012 03:46:00 GMT

IPCs are a great feature as it allows you to call sub-processes from a main process. However, a customer recently asked me when they should be using IPCs and when not to. This is a tricky question to answer. It should be noted that IPCs are in general a bit more expensive in terms of execution (as we are creating another process instance and also maintaining IPC records to track the relationship). In general, there are two scenarios that would call for IPC usage: When you have sub-processes that...(read more)

K2 XML Fields and XML Schemas

chrisg — Mon, 09 Jul 2012 19:23:00 GMT

K2 BlackPearl allows you to define XML fields within a process that can be used to store XML data / documents that are used by the process and / or its user interface. Please note that the K2 process may store multiple copies of the XML field for auditing purposes, which if large can consume a large amount of space in the K2 databases. As such it is generally not wise to store large document attachments inside the XML stored in the K2 process.

XML Schema

When defining XML fields in K2 you can specify a Schema which is used by K2 to enable to object browser to display the structure of the XML. This is the difference between seeing a monolithic XML field where K2 is only aware that it has an XML document and in seeing a graphical hierarchical representation of the XML data where each field can be used in the process via drag and drop. Note the difference in the two XML fields defined below: With Schema and Without Schema.

By providing a schema and allowing the object browser to display the data structure a great deal of custom code and manual XML manipulation can be eliminated.

Please be aware that while you can provide a schema K2 does not perform a strict validation of the XML either when setting the value via the API or when consuming the data from within the process. Thus, there are no issues with adding new elements and/or attributes to the XML that are not in the schema. This loose coupling provides the advantages of being able to easily access fields defined in the schema from within the K2 Design Tools while maintaining the flexibility to allow external systems to extend the XML without requiring you to update the K2 process definition. Obviously, it is possible to have breaking XML changes such the removal of a field that the K2 process is using, but this would be an issue even with custom code where an XSD is not defined within K2.

An XML Schema file (*.XSD) can easily be created from a representative sample XML file using the XSD.exe utility found in the Windows Platform SDK.

The simplest use of this utility is simply (with the Win SDK in the path) is

XSD.exe Source.xml

An additional useful option is /outputdir which allows you to specify where the XSD should be written.

CSD.exe Source.xml /outputdir:”C:\XSDOutputFolder\”

For additional information about XSD.exe please reference: http://msdn.microsoft.com/en-us/library/x6c1kb0s(v=vs.100).aspx

In the K2 Object Brower switch to the third vertical tab button named, “Process / Activity Data”. Expand the XML Fields tree node as shown and right click on the Process name (‘XML Test’ is this case) and click Add (shown below).

This will open the Add XML Field dialog. Type a value in the Name field

Switch to the XML Schema tab, click the Browse button and select the XSD file created in the previous step and click Open. The XML Schema tab will look similar to the following depending on the namespace used in the Schema.

Click OK. You should now have a new XML field in the object browser. Note, how you can see all of the child elements even the ones nested multiple levels deep. Any of these can be used with the K2 wizards including Smart Objects (SmO) calls without needing custom code to extract and store the values in data fields.

This blog written by Jon Coign

Access SQL Server Information for a K2 process Part 2

chrisg — Mon, 02 Jul 2012 18:47:00 GMT

In the previous post, I showed you how to expose SQL Server objects such as tables and stored procedures as SmartObjects in K2. In this post, we’ll take it one step further and actually work with SQL information by using a SmartObject inside a K2 process.

As you already know, K2 offers a dynamic SQL Service broker that can be used to immediately access SQL information. Basically there are 3 options available for registering a new SQL Server Service Instance:

•    Broker Management Tool: < Installation Directory>\ServiceBroker\BrokerManagement.exe
•    SmartObject Services Tester Tool: < Installation Directory>\bin\SmartObject Service Tester.exe
•    K2’s SQL Server Data Management: SharePoint Central Administration

Previously, I used SharePoint Central Administration to generate the SQL SmartObjects for my database. K2 automatically generated the basic CRUD functionality for these database tables (and also provided a List method). By default, when K2 generates the SmartObjects through the SharePoint Data Management interface (in Central Administration), they are placed within the SQL Category as shown below through K2 Studio:

Great, now that we have our SmartObjects, how do we use them within K2?
Firstly, K2 offers 3 design canvases to create workflows:
•    K2 Designer for SharePoint – Offers a no-code design experience, browser-based, and fully-housed in SharePoint, allows you to create SharePoint based solutions
•    K2 Studio – Offers a no-code design experience, allows you to create both SharePoint and non-SharePoint based solutions, more functionality including the ability to create SmartObjects
•    K2 Designer for Visual Studio – All the features in K2 Studio and more, including access to code.

For more detailed information on these canvases, check out www.k2.com
In this example, we will be using K2 Studio. But, keep in mind that K2 Designer for Visual Studio offers pretty much the same design experience as K2 Studio.

For K2 Designer for SharePoint, you will need to configure access to the SmartObjects through SharePoint. The main reason for this is that often times, you may not want to expose critical system functionality to the broader SharePoint audience. For this reason, K2 allows you to select which SmartObjects methods you’d like to expose. This setting can be accessed in SharePoint via K2 Site Settings. Within the K2 Site Settings, under the K2 Designer for SharePoint Management section there is a link to Configure SmartObject Access. After you configure access to the SmartObjects, you will see a new tab appear in the K2 Designer for SharePoint which will allow you access to SmartObject methods:

Now back to K2 Studio, to invoke any of the SmartObject’s methods is really easy. In K2 Studio (and K2 Designer for Visual Studio), all you need to do is drag the SmartObject Event onto the Design Canvas (see below):

A wizard will then appear to guide you through the specific configuration steps for the SmartObject method.

For example, let’s say that we’d like to create a new Applicant from within the process.
First we need to click Next, this will take us to the screen where we specify the SmartObject method that should be called. In our scenario, we need to locate the “Create” method for the Applicant SmartObject (from within the Context Browser). The Context Browser is accessible either through the ellipsis button or by clicking on the arrow found on the right-side of the wizard (see below):

In the top tab of the Context Browser, you will see the SmartObject Server section, expand this section and locate the SmartObject and the method you’d like to invoke. In this example, we will drag-and-drop the Applicant SmartObject’s “Create” method from into the SmartObject Method (see below).

Now that we have defined our SmartObject method, click Next, and the Wizard will guide us through the remaining configuration items such as input parameters and output parameters, which can be a combination of data process fields or statically defined inputs (as seen below):

At this point, we can click Finish, or we can store the output (ie. like an ApplicantID) for future use. And that’s it!

To summarize, we’ve used a SmartObject inside a K2 process to create information inside a SQL Server table. In other words, we created a new applicant within the Applicant SQL table, without code. We did this by using the Applicant SmartObject (which was generated by K2), then invoking its Create method from within a K2 process.
As you can see, SmartObjects are an important part of the K2 platform, not only in terms of integration but they also allow non-technical (and technical) people the ability to easily work with information stored in different line of business systems to create powerful-process driven applications.

This blog written by Melissa Layupan

Consolidating Views

chrisg — Mon, 25 Jun 2012 19:57:00 GMT

K2 houses its repositories in Microsoft SQL Server. In a K2 version where there is a single database or older versions where there are multiple databases there is always one data server for each K2 Logical Server/K2 Farm (Network Load Balanced Servers). Organizations may have multiple K2 logical servers/farms which are configured to separate K2 Data Servers for reasons of dividing the company’s workflow, geographically or functionally. In such cases, normally the Worklist and K2 Reports will be aware of only one data server and its content per K2 Farm.

If management then wants to consolidate data content from these separate K2 data servers for a unified report, there are various approaches to take to combine the data. This is not trivial as each data server will have a set of primary keys on its tables which will not be globally unique, and thus the solution to combining the data will require a logical server identifier in combined views or aggregations of the data.

OOTB reports, SmartObjects and several other components of a K2 installation are not able to switch to this “combined” scenario, as they depend on the keys from a single logical K2 data server.

Yes. That means custom reports will need to be constructed over the combined data servers content to accommodate an extra indicator for the data server as part of the various entities’ primary keys.

For example, the Process Instance ID will be unique on K2 Data Server A, as will the Activity Instance ID. These two vital keys combine to make the all-important Serial Number that matches positioning of a workflow instance and activity instances. If one were to combine the data from two separate K2 data servers, those keys will be found again on the second of those data servers, and thus no realization of where the data really is….not to mention keys that cannot properly join n associations to other entities. You have to add a K2 Server ID to make a complex key on Process Instances and Activity Instances.

First approach the data aggregation

Before one begins to register K2 Sql Service Instances for each K2 Data Store and generate K2 ServiceObjects which can be composited to a single K2 SmartObject, let’s consider where processingpower should occur if this combined data access has a chance to perform well.

Since K2 data is housed in Microsoft Sql Server, it is best practice to keep the data combining effort from multiple K2 data servers in the Sql Server Engine before we try to surface it in any data access technology. We will add components to the K2 data servers to make this feasible.

Do not alter the schema of The k2 database

There is no need to alter any parts of the K2 database to enable this functionality. In fact, you may trap yourself if you tried altering K2 data stores (not to mention the invalidation of your license and support). When K2 updates occur – they may impact those data stores. An abstraction concept is needed here to enable responsibility to any changes in K2 database.

The consolidation strategy

As all data servers will be Sql Server instances, we can easily use Linked Servers, a construct which allows for accessing data from different servers from the native or local Sql Server instance. I recommend that a database is created on the business application data servers, since reports will likely be built against these data stores along with other business solution related data of the organization.

The “Biz” Data Server will then “Link” to all of the K2 Data Servers.

Preparation for Linking servers

There is plenty of documentation at Microsoft on using Linked Servers. Using the tools in Sql Server Management Studio (SSMS), you will achieve that I am outlining below with Sql Scripts.

(1) Create a “shell” database on each K2 Data Server. This abstraction will keep hands of the actual K2 database AND enable maintenance as needed in the objects created in the “shell” database to respond to any evolutions that occur in the K2 databases, and preserve your consolidation strategy. I recommend these are contained in a schema as well, which is created as well as shown in this script.

(1) Create Views in the “shell” database qualified by the database name, schema and object. Alias all the columns so this abstraction will always expose a consistent column name.

Here are more samples of possible views

(1) This is a possible sample for retrieving data the same as some OOTB SmartObjects. This is a reworked version of the query that extracts Activity Destination Instances.

PART 1 – Output columns

PART 2 – remaining output columns

PART 3 – Begin From Clause

PART 4 – Begin First of three sub-queries, columns

PART 5 – First sub-query “Duration” column

PART 6 – End of first sub-query

PART 7 – Second sub-query

PART 8 – Third sub-query

PART 9 – Other Joins/Lookups

The SECURE CONNECTIONS

To prepare for Linking Servers, create a SQL Login account on the K2 Data Server and on the “shell” and K2 databases.

CREATE THE LINKED SERVERS

Now, on the Business Data Server, you can make Linked Servers to the K2 Data Servers.

CREATE THE DISTRIBUED VIEWS

Now create a schema to hold the distributed views to be made over the linked servers.

A sample Process Instance View

A sample Activity Instance View

Sample Activity Destination Instance View

PART 2

This blog written by Jeff Belnap

K2 4.6.1 Tip of the Day : ADUM Logging

johnny — Fri, 22 Jun 2012 04:17:00 GMT

Saw this useful tip on the grapevine (Thanks to Vernon for this) when troubleshooting issues with the Active Directory User Manager (ADUM) provider. In 4.6.1, more advanced debugging can be enabled by setting additional flags in the RoleInit field in the SecurityLabels table in the K2HostServer database. There are two settings explained in KB001286 , LogLevel and LogSize . LogLevel values can be set to None , Error , Debug , All (in order of increasing amount of log data). LogSize specifies the size...(read more)

Access SQL Server Information for a K2 process Part 1

chrisg — Mon, 18 Jun 2012 15:58:00 GMT

A common question I receive is how to access SQL Server information from within a K2 process. So, I thought I’d dedicate a couple posts around how to do just that, this is actually Part 1 of a 2 Part series. In part 1, I’ll show you how to expose SQL Server information (like SQL Tables) as SmartObjects in K2. For part 2, we’ll take a look at how you can access the SmartObjects from within a K2 process.

In this scenario, we will begin to create an Employee Onboarding process which needs access to information stored within a company’s HRIS database. Since the database is a SQL Server database, we can use the out-of-the-box Dynamic SQL Server Service Broker which is provided by K2.

In blackpearl, you have a few options for registering the Service Instance to the HRIS database. For example, you can use:

· Broker Management Tool: < Installation Directory>\ServiceBroker\BrokerManagement.exe

· SmartObject Services Tester Tool: < Installation Directory>\bin\SmartObject Service Tester.exe

· K2’s SQL Server Data Management: SharePoint Central Administration

Of the 3 options above, I find myself spending the most time within SmartObject Services Tester tool. It’s a great utility tool for not only registering new Service Brokers (and their instances) but it also makes it easy to create and test SmartObjects outside of K2’s designers, which is really valuable since often times you’ll want to test that your SmartObjects work as expected before wiring them up to a process.

In this example, we will be using the K2’s SQL Server Data Management found within SharePoint Central Administration to generate our HRIS SmartObjects.

*As a side note, even though I will be using Central Administration to create the HRIS SmartObjects (mainly because this technique applies to both K2 blackpearl and blackpoint), I’d still like to suggest that you check out the SmartObject Services Tester Tool if you haven’t done so already, hopefully you’ll find it as useful as I do.

In Central Administration, go to the K2 for SharePoint then look for the Data Management section. Located within the Data Management section is a link to Manage SQL SmartObjects (see below).

Clicking on the link will take you to a page which lists all the different databases that K2 currently accesses. On this screen, click the New Connection link at the top:

Now specify the details of the connection such as:

Connection Settings

· Connection Name: This is the name of the connection. The name is typically something that let’s other users know what the connection is for. In my case, since I’m connecting to the HRIS database, I’ll name my connection: HRIS.

· Description: Enter a description for the connection (optional)

SQL Settings

· Server: This is the name of the SQL Server.

· Database: The name of the database.

· Authentication: Specify the credentials for authentication to the database

Database Settings:

· Authentication: Specify the credentials for retrieving schema information

In this example, the connection information looks as follows:

Once the connection information is filled out, click the “OK” button.

K2 will then use the Dynamic SQL Server Service broker in conjunction with the connection information to retrieve the database’s objects like the tables, stored procedures and views.

K2 will then allow you to “check” all objects you’d like to create SmartObjects for:

In my sample database, I only have 4 tables, so I’ll select everything and click the Create button. K2 will now automatically generate the corresponding SmartObjects for each of the tables I’ve selected. These SmartObjects will contain the basic CRUD functionality as well as a List operation, and by default, K2 will place the SmartObjects within the SQL Category.

Now that the SmartObjects are created, this means that they are also available for use within a K2 process and can be accessible via K2 Studio and K2 Designer for Visual Studio. For example, when I open K2 Studio and open the Objects Browser, and expand the SQL folder under the SmartObject Server, you’ll notice a new folder named “HRIS” which contains all of the newly created SmartObjects (see below):

In this post, we’ve seen how K2 simplifies SQL Server data access by providing the Dynamic SQL Server Service broker. This service broker allows you to quickly work with and gain access to information stored within SQL Server. In my next post, we’ll see how you can use the SQL SmartObjects within a K2 Process.

This blog post Written by Melissa Layupan

How to Automate Document Assembly from within a K2 Process

chrisg — Mon, 04 Jun 2012 20:04:00 GMT

In this article, I will show you how to create new documents from within a K2 process.
Automating content is an essential component to those committed to a paperless office. Especially in terms of time, savings, and convenience, document assembly is shown to be a huge win for document-centric processes such as contract management, HR, legal, compliance, etc.
What you’ll need:
•    K2 (blackpoint/blackpearl)
•    SharePoint (MOSS, 2010)
•    Microsoft Word
Step #1: Create a Template
The first step is to create a Word Template for the type of document you’d like to assemble. In my example, I am creating a template for a Proposal Letter that will be sent out to prospective customers:

Step #2: Add Content Controls
Now that we have our template, the next step is to add some Content Controls. These Content Controls act as placeholders for the dynamic content that will be added later to the document via K2.
First, you’ll need to verify that you can access the Developer tab within the ribbon:

If you do not see the tab, then you’ll need to enable it. Please refer to the following link for instructions: http://msdn.microsoft.com/en-us/library/bb608625.aspx
Next add a control to the template by putting the cursor to where you’d like the content control to appear then click on the Plain Text Content Control:

Now you’ll need to provide your content control with a meaningful name by clicking on Properties:

For my template, I am adding a content control to hold a name, so I updated the Content Control Properties as:

Your first content control should look something like this:

You can add as many content controls as you wish, this can include any piece of information that K2 has access to such as values from a database, calculations, or dates.
Step #3: SharePoint – Update Document Library Template
Now that we have our document template, we need to upload this template to a SharePoint document library. In my example, I am going to create a new document library and update the base Document content type template:
•    In your document library
o    Goto the Document Library Settings
o    Click on Advanced Settings -> Allow Management of Content Types (yes)
o    Click on the Document Content Type located within the Content Types section
    Click Advanced Settings
    Upload your document template

Step #4: K2 – Assemble the document from within a K2 process
Included in all of K2’s design canvases is the K2 Word Wizard. This wizard allows you to build documents on the fly in K2 by leveraging SharePoint and Word Services. I am going to use the K2 Designer for SharePoint to assemble the proposal letters, but you can also use K2 Studio and K2 Designer for Visual Studio to do the same thing.

First let’s create a new document, by dragging the ‘Create Document’ wizard onto the design canvas and filling out the information:

•    Select the document library – Select the document library that holds your template. Note that the generated file will be found in this library.
•    Document Reference Name – This is the K2 process reference to the newly created document (we will use this reference later to set the data in our Content Control)
•    Content Type – The content type of the document. In my case, I updated the template for the base Document content type, so I will leave it as Document.
•    File Name – The name of the generated file.
Now let’s update the Content Control inside my template. For that, we’ll need to add a new workflow step and drag onto the step the ‘Update Document Content Control’ wizard. Let’s now complete the wizard by filling in the missing information:

On this page, we need to enter 3 pieces of information:
1)    From (Text) – This field defines the value for the Content Control. I am selecting the ‘Text’ option because the value is text-based. In this case, I just typed in my name but you can use information in the Context Browser (or process variables) just the same.
2)    Into (Referenced Document) – We need to specify the document that needs to be updated. In the previous ‘Create Document’ wizard we defined the reference value.
3)    Into (Content Control Name) – This is the name of the content control to update. In my template, content control was named ‘Name’, so I just typed it in, but again, you can set this field using the Context Browser or process variables.
In the end, my simple example process looked like this:

After running the process, the newly created document will be found in the same document library where the template was updated…. And here’s how it looks:

Hopefully, this article gave you some ideas of how you might be able to leverage K2 in your different document automation scenarios.

This blog post by Melissa Layupan

Using Linq for XML in K2

chrisg — Tue, 29 May 2012 14:45:00 GMT

1) Overview

With the addition of the Data Event to K2 blackpearl, the requirement to drop into code to work with XML data has been significantly reduced. But it still happens. Fortunately, gone are the days of guesstimating X-paths and troubleshooting unreadable namespaces to find a required value in the maze of an XML document – enters Linq for XML (refered to as XLinq onwards). XLinq allows the developer to write SQL-like queries in code against an XML document to find a specific XML node, or a collection of nodes.

In the System.Xml namespace coding paradigm, the XML is formatted into a tree structure where a specific node in that tree can only be found by determining its relative path to the root node (i.e. the X-path), thus access to any node in the Xml document starts at the root node. Contradictory, the System.Xml.Linq coding paradigm of XLinq sorts all the nodes in the XML document in a long, single-file list where nodes can be accessed at random using their name in select-statements (queries). Once the required node has been selected, relational nodes (parent, siblings, descendants, etc.) can also be found easily.

When learning XLinq, Google will be your best friend – there is a ton of information out there. Here is two articles that I found:

http://msdn.microsoft.com/en-us/library/bb387087.aspx

http://www.dreamincode.net/forums/topic/218979-linq-to-xml/

For the purposes of this blog, I’m going to stick to the objects and techniques to work with Xml-Fields in the context of a K2 blackpearl process, but should be general enough to be applied to other development areas. Hopefully this will explain the power of using XLinq when you need to drop into code.

2) The Usual Suspects

To start using XLinq, you need to include the following namespaces in your Default Server Event code:

using System.Linq;

using System.Xml.Linq;

Within the System.Xml.Linq namespace, you’ll be using the following classes:

· XDocument

· XElement

· XAttribute

The XDocument class is used to read the XML string into a usable object, which is very similar to System.Xml.XmlDocument class used previously. The XDocument object contains the undated value of the XML if it was updated as part of your code. This class will be used to read the K2 Xml-Field’s value, and to update its value at the end of your Default Server Event code.

The XElement class is used to represent a XML node (my understanding – may not be politically correct) within your XML document. This object provides the following methods, which is commonly used:

· Ancestors() Returns list of all the nodes ‘above’ (not just parent) a specific XML node in the XML document

· Attributes() Returns a list of attributes for the XML node

· ElementsAfterSelf() Returns a list of all sibling-nodes after the XML node

· ElementsBeforeSelf() Returns a list of all sibling-nodes before the XML node

· Descendants() Returns all nodes ‘below’ (not just children) the XML node in the XML document

This class is basically the ‘worker’ class and is used to find/query XML nodes, update or remove them.

The XAttribute class is used to work with the attributes for a XElement object.

3) The script

The XML below is used in the remainder of the blog in the concepts, examples and coding techniques. Note that the XML structure is similar ( I customized it for some of the examples) to that of a Process Xml-Field created when an InfoPath form is integrated into a Process Definition.

<my:myFields>

<my:CreatedBy>Eugene Jones</my:CreatedBy>

<my:DateCreated>04/10/2012</my:DateCreated>

<my:ProcessID ProcessName="SomeProcess" StartDate="04/12/2012">14</my:ProcessID>

<my:StartView>

<my:No>1234</my:No>

<my:Comments>Some comments</my:Comments>

<my:SerialNumber>SN9284</my:SerialNumber>

<my:MachineID>284</my:MachineID>

<my:WarrantyAdminADAccount>DENALLIX\Blake</my:WarrantyAdminADAccount>

<my:Distributor>

<my:DistributorID>5</my:DistributorID>

<my:DistributorName>ACME Int</my:DistributorName>

</my:Distributor>

<my:SomeAttachment xsi:nil="true"></my:SomeAttachment>

<my:MyContacts>

<my:Contact No="2">

<pc:Person>

<pc:DisplayName>Bob Maggio</pc:DisplayName>

<pc:AccountId>DENALLIX\bob</pc:AccountId>

<pc:AccountType>User</pc:AccountType>

</pc:Person>

</my:Contact>

<my:Contact No="1">

<pc:Person>

<pc:DisplayName>Codi Kaji</pc:DisplayName>

<pc:AccountId>DENALLIX\codi</pc:AccountId>

<pc:AccountType>User</pc:AccountType>

</pc:Person>

</my:Contact>

<my:Contact No="3">

<pc:Person>

<pc:DisplayName>Mike Tally</pc:DisplayName>

<pc:AccountId>DENALLIX\mike</pc:AccountId>

<pc:AccountType>User</pc:AccountType>

</pc:Person>

</my:Contact>

</my:MyContacts>

</my:StartView>

</my:myFields>

4) Practical Examples – working with XLinq

4.1) Act I: Get XML into and out of XDocument

The first step in working with XLinq is read the XML into a XDocument object. This can be done either from a XML file or XML string value. Here is how to do it:

// Read from XML file on file-system

System.IO.StreamReader fileReader = new System.IO.StreamReader(@"C:\temp\myForm.xml");

XDocument xDoc = XDocument.Load(fileReader);

fileReader.Close();

fileReader.Dispose();

// Read from XML string

XDocument xDoc = XDocument.Parse("<XmlStart>...</XmlEnd>");

To obtain the complete XML string, it is as easy as to call the ToString() method on the XDocument object.

xDoc.ToString();

4.2) Act II: Select a specific node using its name

Now that we have our XML in the XDocument object, this object can be used to find a specific node in the XML document. For example, to find the my:SerialNumber node (my:myFields/my:StartView/my:SerialNumber), the following code can be used:

XElement xSerialNumber = (from item in xDoc.Descendants()

where item.Name.LocalName == "SerialNumber"

select item).FirstOrDefault();

The FirstOrDefault() method states that if the query returns multiple matches, the first node should be used. To get the actual value for the SerialNumber node, the following code can be used:

string serialNumber = (from item in xDoc.Descendants()

where item.Name.LocalName == "SerialNumber"

select item.Value).FirstOrDefault();

string serialNumber = (from item in xDoc.Descendants()

where item.Name.LocalName == "SerialNumber"

select item).FirstOrDefault().Value;

Set the value of a node, the SetValue() method can be used. Note that this method updates the actual XML in the XDocument object.

XElement xDistributorName = (from item in xDoc.Descendants()

where item.Name.LocalName == "DistributorName"

select item).FirstOrDefault();

xDistributorName.SetValue("ACME Supplies Inc");

4.3) Act III: Select a multiple nodes using conditions

Working with a collection of nodes/repeating nodes in Linq for XML is really easy. To select all the my:Contact nodes in the <my:MyContacts></my:MyContacts> section, the following code can be used:

List<XElement> myContacts = (from contact in xDoc.Descendants()

where contact.Name.LocalName.ToUpper() == "Contact".ToUpper()

select contact).ToList();

To select all the pc:AccountId nodes, and to sort them by name, the following code can be used:

List<XElement> myContacts = (from contact in xDoc.Descendants()

where contact.Name.LocalName.Contains("AccountId") == true

orderby contact.Value

select contact).ToList();

To order descending, use:

List<XElement> myContacts = (from contact in xDoc.Descendants()

where contact.Name.LocalName.Contains("AccountId") == true

select contact).OrderByDescending(x => x.Value).ToList();

4.4) Act IV: Working with attributes

To get the XAttributes for a node, you have to get a XElement object to the node first. To get the ProcessName attribute of the ProcessID node, the following code can be used:

XElement xProcessID = (from item in xDoc.Descendants()

where item.Name.LocalName == "ProcessID"

select item).FirstOrDefault();

XAttribute xProcessName = (from attribute in xProcessID.Attributes()

where attribute.Name.LocalName == "ProcessName"

select attribute).FirstOrDefault();

Attributes can also be used to filter and sort a list of repeating nodes. For example, to return all the Contact nodes of which the No attribute is greater than one and sorted numerically, the following code can be used:

List<XElement> myContacts = (from item in xDoc.Descendants()

where ((item.Name.LocalName == "Contact") && (Int32.Parse(item.Attribute("No").Value) > 1))

orderby Int32.Parse(item.Attribute("No").Value)

select item).ToList();

4.5) Act V: Changes to the XML document

First thing to understand is that any change made to an Linq for XML object is immediately reflected in that object’s ‘parent’ object(s). To explain this behaviour, consider the following code:

// Read from XML file on file-system

fileReader = new System.IO.StreamReader(@"C:\temp\myForm.xml");

xDoc = XDocument.Load(fileReader);

fileReader.Close();

fileReader.Dispose();

// Example 1

// Find the my:DistributorName node

XElement xDistributorName = (from item in xDoc.Descendants()

where item.Name.LocalName == "DistributorName"

select item).FirstOrDefault();

// Set the new value for the my:DistributorName node

xDistributorName.SetValue("ACME Supplies Inc");

// Example 2

// Find the ProcessID node

XElement xProcessID = (from item in xDoc.Descendants()

where item.Name.LocalName == "ProcessID"

select item).FirstOrDefault();

// Find the ProcessName attribute of the my:ProcessID node

XAttribute xProcessName = (from attribute in xProcessID.Attributes()

where attribute.Name.LocalName == "ProcessName"

select attribute).FirstOrDefault();

// Set the new value for the ProcessName attribute

xProcessName.SetValue("NewProcessName123");

In the Example 1 above, the xDoc object is used to create/find the xDistributorName object. When the xDistributorName object’s value is updated, this change is immediately reflected in the xDoc object. Similarly in Example 2, the xDoc object is used to create/find the xProcessID object, which then used to create the xProcessName object. When the xProcessName object’s value is updated, the change is immediately reflected in both the xDoc and xProcessID objects.

Example 1 above shows how to update the value of a node in the XML document, whereas Example 2 shows how to update the value of an attribute. Below is other common changes that are done to the XML document.

To remove a node (my:DistributorID in this example) from the XML document, the following code can be used:

// Example 3

XElement xDistributorID = (from item in xDoc.Descendants()

where item.Name.LocalName == "DistributorID"

select item).FirstOrDefault();

xDistributorID.Remove();

Note that the Remove() method also removes all the nodes child-nodes from the XML document. The RemoveAll() method on the other hand basically ‘clears’ the node from all attributes and children and sets the node to an empty value.

To remove a list of nodes (my:Contact in this example) from the XML document, the following code can be used:

// Example 4

List<XElement> myContacts = (from contact in xDoc.Descendants()

where contact.Name.LocalName == "Contact"

select contact).ToList();

foreach (XElement xContact in myContacts)

{

xContact.Remove();

}

To remove an attribute (StartDate from the my:ProcessID) from a node in the XML document, the following code can be used:

// Example 5

XElement xProcessID = (from item in xDoc.Descendants()

where item.Name.LocalName == "ProcessID"

select item).FirstOrDefault();

XAttribute xStartDate = (from attribute in xProcessID.Attributes()

where attribute.Name.LocalName == "StartDate"

select attribute).FirstOrDefault();

xStartDate.Remove();

To create a new attribute for a node (my:Comments in this example) in the XML document, the following code can be used:

// Example 6

XElement xComment = (from item in xDoc.Descendants()

where item.Name.LocalName == "Comments"

select item).FirstOrDefault();

xComment.SetAttributeValue("NewAttributeName", "New Attribute Value");

Finally, here is the code required to empty-out an attachment control value in the InfoPath Form XML:

// Read from XML from the InfoPath Form XML field

xDoc = XDocument.Parse(K2.ProcessInstance.XmlFiels["myInfoPathForm"].Value);

// Create the required ‘xsi’ namespace object

XNamespace xsi = "http://www.w3.org/2001/XMLSchema-instance";

// Find the my:SomeAttachment node in the XML document

XElement xAttachment = (from items in xDoc.Descendants()

where items.Name.LocalName == "SomeAttachment"

select items).FirstOrDefault();

// Set the value of the node to an empty string

xAttachment.SetValue(string.Empty);

// Create and add the ‘xsi:nil’ attribute to indicate to InfoPath that the node is empty

if (xAttachment.FirstAttribute == null)

{

xAttachment.Add(new XAttribute(xsi + "nil", true));

}

// Save the XML data back to the Process Xml-Field

K2.ProcessInstance.XmlFiels["myInfoPathForm"].Value = xDoc.ToString();

Hopefully this blog gave you some insight into using XLinq with XML data within a K2 Process and in general, as well as to provide you with some handy XLinq techniques.

Blog by Eugene Jones. Technical Consultant

How to Write a Generic K2 Helper Class

chrisg — Mon, 21 May 2012 17:18:00 GMT

1. External Assemblies

When there is a need to use custom code it can be placed in an external assembly that is deployed to the GAC. This is especially advisable when the code can be reused in multiple events and / or processes.

1.1. GAC Deployment

To deploy a custom assembly to the GAC is must be signed with a Strong Name Key and placed in the GAC with GACUTIL.exe on both the developer’s machine as well as all K2 server(s) in the target environment(s).

1.1.1. Strong Name Key

In Visual Studio 2010 the project containing the custom assembly can be configured for signing in the Project Properties screen, signing tab. On this tab check “Sign the Assembly” and specify the Strong Name Key (*.snk) by either browsing to an existing file or creating a new key.

1.1.2. Deploy To GAC with Post Build Event

To automatically copy the file to the development machine GAC on build a post build event can be specified in the Project Properties screen, Build Events tab.

The complete command line is as follows:

"C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\GacUtil.exe" /i "$(TargetPath)"

Note the use of the Visual Studio Macro, “TargetPath” which starts begins with the ‘$’. This provides the target path for the assembly when it is built that will be deployed to the GAC.

If you are using .NET Framework 4.0 you will need to use the GacUtil located at C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools\GacUtil.exe as Microsoft has created a separate GAC and utilities for Framework 4.0 since the CLR was updated in 4.0 release. For more information on this please reference: http://www.davidyardy.com/blog/post/2011/03/02/NET-4-New-GAC-LocationsGacUtil.aspx & http://blogs.msdn.com/b/mjeelani/archive/2010/06/07/top-2-things-you-should-know-about-the-global-assembly-cache-gac-in-net-4-0.aspx

Similar approaches using batch files can be used to deploy DLLs to the K2 Servers.

1.1.3. Caching by K2 BlackPearl Server Service

The K2 BlackPearl Server Service has a caching mechanism that may be caching the GAC’d dll, which will prevent K2 server from immediately detecting and loading the updated DLL. In order to ensure the updated assembly is loaded immediately it is necessary to restart the K2 BlackPearl Windows Service.

1.1.4. In-Flight Processes

Sometimes when an external assembly is updated there will be new / modified functionality to support changes / extensions to existing processes which already have instances running on the server. To prevent negatively impacting these processes it is recommended that existing public interfaces not be broken and that implementations do not change in such a way that would cause these in-flight instances to go into an error state. To facilitate this it is better to add new methods or interfaces to the assembly depending on the scope of the change. This allows the in-flight processes to finish completed effectively against the same code base while allowing new process versions to start using the new code immediately.

1.2. K2 Server Event Context

It is possible to use the K2 Server Event Context within the external assembly by passing in the appropriate Context object. In the custom assembly it will be necessary to reference KO.dll as shown below.

Note: If browsing to the DLL makes sure you use the one in “C:\Program Files (x86)\K2 blackpearl\Bin” folder. Using another copy that belongs to the K2 Service could cause issues when the K2 installation is upgraded to a newer build.

Which once referenced will be displayed in the project as follows:

Once referenced this can be utilized as shown in the method below when uses the K2 Server Event Context to access the string table and return the Mail Server connection information.

public static string

GetMailServerFromStringTable(SourceCode.KO.ServerEventContext K2Context)

{

return K2Context.StringTable["Mail Server"];

}

The calling code in the K2 process shown in the next section will pass in the appropriate context object that this method requires.

1.3. Consuming an External Assembly from a K2 Process

1.3.1. Reference External Assembly

To use an external assembly in a .NET process it must first be referenced by click on the Process References button in the upper right hand corner of the K2 Design Canvas in Visual Studio (shown below).

In the resulting dialog box (shown below) click Add.

Locate the assembly that was GAC deployed, click it to make sure it is highlighted and then click the select button, such that is shows up in the Selected Items pane (Shown Below) and then click OK.

The assembly should now show up in the Process References dialog.

Click Finish

1.3.2. Calling the Custom Assembly

To call a method in the external assembly drag a “Default Server Event (Code)” event onto the appropriate activity.

Once the event is on the canvas, double click and specify a descriptive name, “Call GAC'd DLL” in this example. Right click on this event and select View Code à Event Item as shown below.

This will bring up the code for the empty Main method that initially defines this event. To call the custom assembly, which in this case returns a string and expects the K2 Server Event Context we can add the following code.

public void Main(Project_4d6283f2d66a432e9cef761881dd7432.

EventItemContext_37d8f16b33344710ac50bd16a9c4e9d9 K2)

{

K2.ProcessInstance.DataFields["GAC Output2"].Value =

GAC_Test.Email.GetMailServerFromStringTable(K2.GetServerContext());

}

Note that the K2 object passed to the Main method is not a type that is easily consumed at design time as such we call the GetServerContext Method to get the more easily used “ServerEventContext” object, which contains the most commonly needed properties or methods. If additional data is needed is not available from this object simple create additional input parameters of the needed type.

Blog written by Jon Coign

Integrating K2 Client Events with Dynamics CRM 2011 using K2 Services

anders98 — Thu, 10 May 2012 20:18:00 GMT

This article will show how to use a Dynamics CRM 2011 form in a K2 client event to action tasks during a K2 process. The article uses only out of the box K2 components, Dynamics CRM 2011 customizations and some relatively simple JavaScript.

This article assumes that you have knowledge of the following:

Customizing Dynamics CRM 2011
JavaScript & JQuery
K2 Process Design
K2 Development

Scenario

In this example we are going build a simple lead review and acceptance process however the techniques are applicable to any K2 and Dynamics CRM 2011 solution.

K2 Services

To quote the K2 documentation,

The K2 Services provide out of the box web service functionality for a portion of the SourceCode.Workflow.Client namespace via common Web service endpoints, such as RESTful web services (REST – Representational State Transfer), Windows Communication Foundation (WCF) and legacy SOAP (WS). Developers familiar with the SourceCode.Workflow.Client APIs will be able to quickly start using the REST, WCF or WS endpoints in their applications.

In this article we’ll be using the REST services to retrieve and action K2 worklist items via the Dynamics CRM 2011 form.

It is not the intent of this article to provide a deep dive into K2 Services. The K2 Developer documentation goes into considerable detail about both their configuration and their usage which I strongly encourage you to read.

It is however important that these services be configured correctly to ensure they are callable from our CRM form.

Validate that the services are configured correctly by navigating to the service in a browser. Modify the URI based upon your configuration.

This will return a XML representation of the current user’s K2 worklist.

http://dlx.denallix.com:81/K2Services/REST.svc/Worklist/Items

Customize Dynamics CRM 2011 – Part 1

With the K2 Services configured we can begin modifying Dynamics CRM.

NOTE: During the course of this article we will be using unmanaged solutions or direct customizations.

We are going to be using JQuery in our form customization so if JQuery is not part of your CRM 2011 environment download it from http://jquery.com/ . At the time of writing this article the current version of JQuery is 1.7.2.

In Dynamics CRM 2011 go to the Settings –>Customizations –> Customize the System

Add a new Web Resource for JQuery 1.7.2 and publish the customization.

Add another Web Resource for the code from the Appendix - K2.Demo.CRM.LeadDemo.js.

We’ll explain the content of this code during the course of the article but the first thing we need to do is make a small modification to the code. Edit the web resource.

Modify the first line so that the K2WFSERVICESBASEURI variable represents your environment’s configuration.

In Customize the System navigate to the Lead entity

Under Fields add a new field. This field will be used to display the actions for a K2 client event.

Display Name: K2 Actions
Requirement Level: No Constraint
Name: [prefix]k2actions
Searchable: No
Field Security: Disable
Auditing: Disable
Type: Option Set
Options:
- Label: Not Applicable
- Value: 100,000,000

The options will be dynamically set when the form is opened in the context of a K2 process.

With the field created let’s go and modify the Lead entity form.

Add a new Tab under the existing Details tab.

Set the tab with the following properties including disabling Visibility by default.

Add the K2 Actions field to the newly created tab.

On the ribbon select Form Properties

Go to the Parameters tab. Add a new parameter called k2_sn of type SafeString. For security reasons Dynamics CRM doesn’t allow you arbitrarily include values in the query string so you must first define a parameter if you wish to do this. This parameter will be used later when designing our K2 process and will hold the serial number of a given user’s worklist item.

Under the Events tab add the JQuery and K2.Demo.CRM.DemoLead web resource that we added previously.

In the Event Handlers section add a method for OnLoad

Library: new_K2.CRM.Demo.LeadDemo
Function: K2OnPageLoad

In the Event Handlers section add a method for OnSave

Library: new_K2.CRM.Demo.LeadDemo
Function: K2OnPageSave

K2OnPageLoad

The K2OnPageLoad method fires when the page loads and does two things.

It retrieves the value of the k2_sn parameter in the query string
If it finds a value, the K2 serial number, it will;
1. Make a call to the K2 Services to retrieve the worklist item
2. Populate the K2 Actions option set with the available actions for the worklist item
3. Show the K2 tab on the form that to this point has been hidden

K2OnPageSave

The K2OnPageSave method fires when the user clicks the Save or Save and Close button on the form. On this event the method;

Checks if the K2 Actions option set has a value and that value is not the default ‘Not Applicable’ value
If an action is selected the worklist item is completed via a call to K2 Services

Dynamics CRM 2011 Forms URL

In order to send the user to the right CRM form when they open the item from their K2 worklist we need to construct the appropriate URL.

Open a Lead in CRM. On the ribbon select the Copy a Link button.

Open Notepad and paste the link

Keep this URL on hand as we are going to use this URL later in the article.

Building the Process

In this section we are going to focus on adding the Client Event to the K2 process and not building the complete process.

Drag the Default Client Event onto the design canvas.

In the Default Client Event wizard add an Event name.

In defining the Task Item URL we could use data fields or environment library settings to avoid hard coding the URL and provide flexibility in moving the process across environments or support multiple CRM organizations but for the sake of clarity in the article we are going to set the literal value.

The Task Item URL will look like the following.

http://crm.denallix.com/Denallix/main.aspx?etc=4&extraqs=k2_sn%3dPROCESS INSTANCE ID_ACTIVITY DESTINATION INSTANCE ID&id=%7bCRM ENTITY ID DATA FIELD%7d&pagetype=entityrecord

To break down the URL

http://crm.denallix.com/Denallix/main.aspx?etc=4&extraqs= - relates directly your CRM implementation. A good candidate for defining as an environment library configuration field
k2_sn%3d – the parameter we added when customizing the CRM Lead form. %3d is a URL encoded equals sign
PROCESS INSTANCE ID_ACTIVITY DESTINATION INSTANCE ID – construct the serial number from the Context Browser. An underscore separates Process Instance ID and Activity Destination Instance ID
&id=%7b - separates end of the serial number and the start of the ID that represents the CRM entity instance you will open. %7d is a URL encoded opening curly bracket {
CRM ENTITY ID DATA FIELD – the process needs to know what CRM entity instance to open. In our example we are assuming you have the process has a data field that holds the GUID of our Lead instance
%7d&pagetype=entityrecord – we complete the URL with the remaining elements. %7d is a URL encoded closing curly bracket }

Ensure that you uncheck the Append serial number to URL checkbox.

You can configure the rest of the Default Client Event wizard as per normal.

Build out the remaining elements of the K2 process.

Testing our Process

Having started out example process the destination users will see a new item in their K2 Worklist

Upon clicking on the worklist item the Dynamics CRM Lead form will open with the corresponding actions populated in the K2 Actions option set.

Conclusion

This article has shown how to leverage the native Dynamics CRM 2011 forms for K2 process client events and can be applied across any entity in CRM.

In truth this is only the start of what is possible. For example, adding the K2 View Flow to the form could be achieved with minimal additional effort.

Appendix – K2.Demo.CRM.LeadDemo.js

var K2WFSERVICESBASEURI = 'http://dlx.denallix.com:81/K2Services/'; var DEFAULTOPTIONSETVALUE = 'Not Applicable'; var K2SN = ''; /***** Load Methods *****/ function K2OnPageLoad() {

// get k2_sn parameter from page url

var extra = new Querystring(getExtraQS());

var sn = "";

sn = extra.get("k2_sn", "");

if (sn != undefined && sn != "") {

K2SN = sn;

getK2WorklistBySN(K2SN);

}

} function getK2WorklistBySN(SN) {

$.ajax({

url: K2WFSERVICESBASEURI + 'REST.svc/Worklist/Items(' + SN + ')?piDataField=true&actXmlField=true&$format=json',

method: 'GET',

contentType: "application/json; charset=utf-8",

dataType: "JSON",

async: true,

beforeSend: function (XMLHttpRequest) {

XMLHttpRequest.setRequestHeader("Accept", "application/json");

},

crossDomain: false,

error: errorWorklist,

success: handlegetK2WorklistBySN

});

} // handles the return of worklist details from getK2WorklistBySN function handlegetK2WorklistBySN(data) {

if (data.Code == "-1") {

alert("The assign K2 task is currently being worked on by another user");

return;

}

if (data.Actions.length > 0) {

// populate K2 Actions option set

var actions = Xrm.Page.ui.controls.get("new_k2actions");

// clear existing options

actions.clearOptions();

//var len = data.Actions.length;

// add an option to the K2 Actions Option Set for each action

for (var i = 0; i < data.Actions.length; i++) {

var actionoption = {};

actionoption.value = data.Actions[i].Name;

actionoption.text = data.Actions[i].Name;

actions.addOption(actionoption);

}

// show K2 tab on form

Xrm.Page.ui.tabs.get("tab_K2").setVisible(true);

}

} /***** Save Methods *****/ function K2OnPageSave() {

// if page in edit more

if (Xrm.Page.ui.getFormType() == 2) {

// check if K2 Actions has a value or is not 'Not Applicable'

// get selected value from k2actions

var selectedK2Action = $("#new_k2actions option:selected").text();

if (selectedK2Action != null && selectedK2Action != "" && selectedK2Action != DEFAULTOPTIONSETVALUE) {

actionK2WorklistItem(K2SN, selectedK2Action);

}

} // actions worklist item with selected action function actionK2WorklistItem(SN, k2Action) {

$.ajax({

url: K2WFSERVICESBASEURI + 'REST.svc/Worklist/Items(' + SN + ')/Actions(' + k2Action + ')/Execute?$format=json',

method: 'GET',

contentType: "application/json; charset=utf-8",

dataType: "JSON",

async: true,

beforeSend: function (XMLHttpRequest) {

XMLHttpRequest.setRequestHeader("Accept", "application/json");

},

crossDomain: false,

error: errorWorklist

});

} /***** Utility Methods *****/ // handles error if returned by getK2WorklistBySN function errorWorklist(data) {

alert(data.status + " - " + data.statusText);

} function getSNParameter() { //var qs = new Querystring(getQueryString());

var extra = new Querystring(getExtraQS());

var sn = "";

sn = extra.get("k2_sn", "");

if (sn != "") {

K2SN = sn;

}

} function getExtraQS() {

var qs = "";

if (parent.location != null) {

qs = parent.location.search.substring(1, parent.location.search.length);

} else {

qs = location.search.substring(1, location.search.length);

}

var qs1 = new Querystring(qs);

var extraqs = removeGUIDBrackets(qs1.get("extraqs", ""));

return extraqs;

} function removeGUIDBrackets(g) {

var u = g;

u = g.replace("{", "");

return u.replace("}", ""); }

function Querystring(qs) {

var querystring = "";

if (qs != null && qs != "") {

querystring = qs;

}

else {

querystring = location.search.substring(1, location.search.length);

}

var args = querystring.split('&');

for (var i = 0; i < args.length; i++) {

var pair = args[i].split('=');

temp = unescape(pair[0]).split('+');

name = temp.join(' ');

temp = unescape(pair[1]).split('+');

value = temp.join(' ');

this[name] = value;

}

this.get = Querystring_get;

} function Querystring_get(strKey, strDefault) {

var value = this[strKey];

if (value == null) {

value = strDefault;

}

return value;

}

K2 SmartActions

chrisg — Wed, 09 May 2012 18:15:00 GMT

Overview

In this post we will cover the mail-based interaction capabilities of the K2 BPM Platform, a technology we call K2 SmartActions. We’ll start by diving into the details around SmartActions then progress to demonstrating how SmartActions can be built into Task Messages, how those messages can be customized and then conclude with how to apply the K2 SmartAction functionality to existing K2 Process Definitions.

What is SmartActions anyway?

K2 SmartActions is a technology that allows for Process participants that receive email Task Notifications to interact with the Workflow Task and the underlying K2 Process via email messages between the user and the K2 Process Server. The goal of this technology is to allow mobile users or user that live within email clients (Outlook, Mail, etc.) the same functionality as users that either interact with K2 Tasks via the K2 Task Worklist or via the associated Task form directly. To accomplish this, we have provided the ability to automatically embed both Task-specific Actions (things like the Approve, Deny, Confer that you’re already building into your Tasks today) along with the standard Redirect, Delegate and Sleep actions that are natively exposed on our K2 Worklist.

A practical example

In our example, we’re going to show the experience of Holly who is a Hiring Manager within the fictitious Denallix organization that has been assigned a task to build out a New Hire Checklist as part of the Employee Onboarding exercise for a new member of her team, Bob. In the “olden days”, Holly would receive a Task notification that could contain data from the Process as well as a link to open the Task form and ultimately Action the task. Holly could also visit her K2 Worklist to see the Task, Actions available for that Task, and additionally be provided the ability to put the task to Sleep as well as Redirect or Delegate the task. With the introduction of K2 SmartActions this functionality has all be combined into a single email notification that Holly can now work from within Microsoft Outlook, via her mobile phone or anywhere else she can received and reply to email messages.

Within the Task notification message we can see that Holly is presented with the following pieces of useful information:

- Task details such as the new hire’s Name, the type of new hire and the employee’s target start date. All these details are useful for being able to make a decision about the Task without having to open the Task form associated to it

- A link to the Task form in case Holly does want to open the Worklist item directly

- Information on how to complete the Task via either custom or standard Actions

Now that Holly has a SmartAction-enabled Task message what can she do with it? For starters she could get some additional information about that task by simply replying to the message with the word ‘Help’. Behind the scenes, K2 is monitoring an email inbox for incoming messages and is configured to pick out certain keywords in the response portion of the email and perform work based upon those words (but more about that later).

In this second email we see that additional Action information is provided:

- For the configured Actions, we include the Action name as well as any additional Action description text (when the Action was built within the K2 Designer)

- For the standard Actions, we include more a more verbose example of what the standard Action does and how to utilize that Action

By parsing through incoming email messages, K2 can now act against these messages to accomplish a few different things:

- Action the task on behalf of the Task owner – once the K2 SmartAction service locates the name of the action in a response, the Task will be auctioned. In our example with Holly if she replied back to the email with the word ‘Completed’ in the body of the message the Task would be actioned Completed.

- Redirect the task to another user – by replying back with either the word Redirect or Delegate and with the target user(s) name or destination account either in the message body or within the CC line of the email then K2 will Redirect or Delegate that Task to the target user specified.

- Putting the task to Sleep – by replying back with the word Sleep and either a date and time or simply a number of hours the task will be put to Sleep and removed from the users Worklist until that Sleep period has expired.

Behind the magic

There are several different components within the overall K2 SmartActions technology that work in conjunction to accomplish the same fidelity of experience in email as from within the K2 Worklist:

- Integration with the mail server

- Enabling Actions to be SmartAction-enabled

- Design of the Task message

- Configuring SmartAction Synonyms

- Customization of response templates

Mail server integration

Upon installation of K2, the installer will ask if K2 SmartActions should be configured and, if so, the location of the mail server and the account used to broker this connection. Sitting underneath K2 SmartActions is an email inbox monitoring service that listens for incoming mail messages and then attempts to parse the message contents looking for certain keywords and an associated K2 Task serial number to correlate against an active K2 Task. NOTE: All mail messages received by this mail box will be parsed in a similar fashion so we recommend not utilizing a shared mailbox for this very reason.

Enabling Actions to be SmartActions-enabled

The K2 BPM Platform allows for the Process Designer to configure which Actions within a Task are accessible via SmartActions by managing the accessibility of that Action within the Task wizard.

When configuring Actions for a given Task you’ll see that same Actions wizard as before:

With the introduction of K2 SmartActions the ability to Action a Work Item is now configurable within the Task Wizard by editing the Action:

By enabling the “Make the action available…” checkbox, the Action for this Task is now accessible in the following locations:

- The K2 Worklist (within SharePoint, within the K2 Workspace, etc.)

- As a SmartAction within a Task Notification email

By disabling this check box, not only will the Action not appear in the K2 Worklist for that given Item, it also won’t be in the body of a SmartAction-enabled Task Notification.

Task notification design

By default, when a user Task is designed within K2 the option is presented to the Process Designer to send a Task notification message to the Task recipient(s). If K2 SmartActions is enabled the message will include some different components than prior version of K2 Task notification messages.

First of these new parts is the requirement of the Worklist Item Serial Number – when allowing the K2 wizard to build the Task message automatically, the Serial Number is automatically embedded at the bottom of the email message in text that most users wouldn’t ever notice. In our example this information is located at the bottom of the message; while there isn’t a hard and fast rule where this Serial Number needs to be, it does have to be present for the K2 SmartAction parser to correlate any email responses to a specific Task.

Next is the addition of the Worklist Item Instance node within the Context Browser – items within this node are specific to the Task and provide an easy way to quickly build out a Task message that provides a great deal of information to the Assignee.

- Configured Actions/Configured Actions with Descriptions – these are the Actions built by the Process Designer.

- Standard Actions/Standard Actions with Descriptions – these are the native K2 Actions (Sleep, Redirect, Delegate)

- Participant name – this is the name of the Task assignee (i.e. ‘Holly Anderson’ in our example above)

Configuring SmartAction Synonyms

A goal of the SmartActions technology aims to allow Task Assignees to respond to Task notification emails and ultimately action Tasks as quickly and easily as possible. To that end, there is also a concept of SmartAction Synonyms which allows for users to use other words/symbols to respond to Task Actions.

For instance, one standard SmartAction response to get more information about a Task is to reply with the word ‘Help’. By default, additional SmartActions for Synonyms are provided natively for Help:

- ?

- H

If an email comes back with either of these in the body, the SmartActions parser will interrogate the Synonyms list, match up the Synonym and then proceed if forward with the Help response.

To see a list of the default SmartAction Synonyms, navigate to the K2HostServer.config file on your K2 Process Server and look for the Configuration > Message Bus > SmartActions > Synonyms:

The Standard Actions section provides the ability to apply synonyms for the out of the box Actions:

SmartAction Synonyms can be added to or removed from this configuration file and will be internalized once the K2 Process Server starts back up. For instance, let’s say that you wanted to provide multi-language support within the context of SmartActions by allowing users to respond to the Help action in German – the result would be something like this:

There is also a section for Configured Actions that can be modified as well:

Customization of response templates

The final piece to the SmartActions puzzle is the standard response templates that come with the K2 Platform – these are used to send messages back from the K2 SmartActions mailbox to users when they respond to K2 Task Notification emails. The configuration of these templates is also stored within the K2HostServer.config file, in the SmartActions > Messages node:

Each node points to a different message template that exists on disk and is used by the K2 Process Server engine to generate mail messages.

Let’s take a closer look at one of these templates – if you navigate to the Templates directory on your K2 Process Server (something like C:\Program Files (x86)\K2 blackpearl\Host Server\Bin\Templates\Messages) then you should see something like the following:

Opening up the associated file for the Help message (SmartActions.Help) should look like this:

We can clearly see that the K2 SmartActions process will use this template and supplement values enclosed in brackets at runtime with values from the associated Task. You may consider changing the content of these files – this would be analogous to changing the standard mail template used for all K2 Mail Events; while this isn’t un-supported, do bear in mind the following:

- These templates are used for ALL Processes/SmartActions so every SmartAction response for the type changed would incorporate these changes

- These templates may be updated during future releases and any customized changes overwritten

- Not including required message part placeholders (the bits between the brackets) could result in undesirable consequences

Applying SmartActions to current Processes

If you were using K2 before SmartActions was released you may have read this blog post and got excited about getting even more value out of the K2 Platform via SmartActions – which is great! One thing to note, simply updating your K2 environment with the latest version won’t automatically start sending out SmartAction Task Notifications – you still need to update your Process definitions and configured those Task Notification emails. Simply re-running through configuring a Task should update the mail template with the required bits for SmartActions to work but this is also a good opportunity to take advantage of some of the additional Worklist Item context or further customize the email notification with a fancier look and feel. Also, you’ll need to verify that the Actions you want surfaced within a notification have been enabled to be actioned without opening the item – again, this isn’t done by default to protect the integrity of the Process but it’s easily modified.

Wrapping up

Within this post you’ve read what K2 SmartActions are, how to apply them to a new or current Process and how to customize the native, out-of-the-box functionality of the feature. We think it’s a very useful feature and we’re glad to continue providing innovation and fantastic features on top of the K2 BPM Platform for you.

Blog Post by Jason Trent

K2 and SSIS

chrisg — Mon, 07 May 2012 15:39:00 GMT

K2 integrates with SQL Server Reporting Services in a number of ways which gives OOTB monitoring and reporting capabilities to tracking workflows and providing some business intelligence. Through the use of a special component, many of these reports are supported by SmartObjects and the means to obtain datasets from them that are consumable to SSRS. This component is the ADO.Net Data Provider for Smart Objects, and can also be used in another Microsoft BI product called SQL Server Integration Services (SSIS).

Part of the power of SmartObjects is the ability to deliver near to real time extractions of data from disparate data sources through a single SmartObject method call. This piece of BI is sometimes referred to as EII (Enterprise Information Integration). It is moving data from the original source and presenting directly to a user interface. This type of data does not allow for analysis in deeper manners, such as slice and dice, aggregations, cross tabulations, and data mining,

Data that is to be analysed is often collected and stored in data warehouses, and even further, pushed into OLAP repositories. A SmartObject does not do this directly. They should not even attempt to be used in this way. ETL (Extract-Transform-Load) tools deliver mechanisms to populate data warehouses for additional crunching. SSIS is a premier tool for doing so, and there is piece of ETL that SmartObjects may support with the correct strategic use -- that is merely the extraction piece of ETL. The same ADO.Net Data Provider for Smart Objects works in SSIS as it works in SSRS. It can deliver datasets to Data Flow Sources in a SSIS package.

1. How TO USE K2 Data Provider in SSIS

SSRS and SSIS have their designers hosted as Business Intelligence Development Studio (BIDS). This will typically be found on a development machine – as BIDS ships with SQL Server and install with the SQL Client Tools. If this development machine has also installed the K2 Development Tools, then the ADO.Net Data Provider is installed and found for use in the BIDs tool.

But the data provider must be installed on SSIS server where it is intended to be used as all data providers for SSIS must be installed.

I will borrow some of the very same steps to installing this data provider manually on SSRS server as the same for installing it on a SSIS Server (to understand the difference of this service engines, see the documentation in SQL Server).

WARNING: Having manually installed the data provider, when you upgrade K2 to a newer version, you will probably have to update the data provider assemblies on the SSIS server too.

First, copy some assemblies from the K2 host server. Find these in the K2 install directory (by default something like C:\Program Files\K2 BlackPearl\Bin):

- SourceCode.Data.SmartObjectsClient.dll
- SourceCode.Categories.Client.dll
- SourceCode.HostClientAPI.dll (Please see 64-bit note below!)
- SourceCode.SmartObjects.Client.dll
- SourceCode.SmartObjects.Management.dll

Note for 64-bit operating systems: The SourceCode.HostClientAPI.dll is compiled to target a specific CPU platform. If you are running a 64-bit operating system in your SSRS environment, you must copy the correct HostClientAPI.dll file from the Global Assembly Cache (GAC) off the K2 server. It will be located in a directory like:

C:\Windows\Assembly\[GAC_64\AMD_64]\SourceCode.HostClientAPI\[4.0.0.0_16a2c5aaaa1b130d]

If you copy the wrong HostClientAPI.dll, you will get an error like 'attempted to load a program with an incorrect format'.

Next, register these assemblies to the GAC of the SSIS server. It is best to use the gacutil.exe utility. If it not installed on the target server, download the windows 7 SDK from Microsoft in order to get it. Find the Windows 7 SDK installer from here:

http://www.microsoft.com/downloads/details.aspx?FamilyID=c17ba869-9671-4330-a63e-1fd44e0e2505&displaylang=en

Next, open the SDK command prompt or a windows command prompt (NOTE: use the 'Run as Administrator' option to launch the command line) and execute as follows:

- gacutil -i SourceCode.Data.SmartObjectsClient.dll
- gacutil -i SourceCode.Categories.Client.dll
- gacutil -i SourceCode.HostClientAPI.dll
- gacutil -i SourceCode.SmartObjects.Client.dll
- gacutil -i SourceCode.SmartObjects.Management.dll

Now configure the ADO.NET Data Provider for SSIS. (Make sure you follow the right path ofor your platform, such as Framework64 paths).

C:\WINDOWS\Microsoft.NET\Framework64\v2.0.50727\CONFIG\machine.config.

Edit the Machine.Config with the assembly references as follows. Scroll down to the bottom of the section </configSections> and enter:

</configSections>

Next, scroll down to the bottom of the section </DbProviderFactories> and enter:

...

<add name="K2 SmartObjects Data Provider"

type="SourceCode.Data.SmartObjectsClient.SOClientFactory, SourceCode.Data.SmartObjectsClient, Version=4.0.0.0, Culture=neutral, PublicKeyToken=16a2c5aaaa1b130d"

description=".NET Framework Data Provider for K2 SmartObjects" invariant="SourceCode.Data.SmartObjectsClient" />

</DbProviderFactories>

Close and save the file, and reboot the SSIS Server

This will make the data provider available for production, and you will be able to see it in Visual Studio 2010 when looking at the Data Connection Wizard. But there is more to do to make the provider available in BIDS.

I recommend that you use development environments where you will have installed the K2 Client Tools and then you will have what you need for BIDS as well. But you only need to do the above, and must do the above to have the Smart Object data provider available for a SSIS Server to call the K2 SmartObject Server.

Confirm that the data provider is in place by checking here in Visual Studio 2010, using the Server Explorer. Open a new connection dialog.

Then click the change button and see that the data provider is listed:

2. How TO Configure a Connection Manager in SSIS

To use the ADO.Net Data Provider for Smart Objects in SSIS, open BIDS and start or open an Integration Services project.

You may create a data source here:

You may also create a Connection Manager directly here:

In the Connection Manager dialog, select the Provider drop down control and select:

Enter the port number and K2Server name:

An ellipse button is available on the Connection property, SmartObjects:

You list the Smart Objects fromt hat server that you wish to be part of the query to made made against it.

Select one or more as if selecting tables, where there is a known relationship between them.

Having done so, the property now appears as:

Click on the test button to ensure the connection goes through (consider the contact of yo0u0r designer and how the session is authenticated.

The Data Source (Connection Manager) wizard is complete by giving it a name. Use a name that conveys the server, the SmartObject usage and the name of the SmartObjects.

Here is the Data Source:

When creating a connection manager, it will be of the type ADO.Net Connection:

Save the Connection Manager with a name as suggested.

With a Connection Manager in place, it may be used as a Data Flow Source. The only access mode is ADO Query (which appears in this designer dialog as SQL command).

3. How TO Best use ADO.NET SOURCE EDITOR (ADO Queries)

The ADO.Net Data Provider for Smart Objects puts an interface on the SmartObject Server data access framework. However, generally, SmartObjects are not intended to query and move tens of thousands of rows of data. It becomes very important that a WHERE clause is part of the query against the data pulled by a SmartObject though its framework up through the data provider ultimately to its consumer. In fact you may to extract data in blocks of rows if the result set would be excessive of 20,000 plus.

Many functions that work in T-SQL will work in the ADO Query. Find the columns to enter from the Smart Object Service Tester, and specify those in WHERE clauses, etc.

Blog post By Jeff Belnap Technical Consultant

Understanding how K2 Project References are used

chrisg — Wed, 02 May 2012 17:36:00 GMT

When adding an external reference (.NET assembly, Web, Service Reference etc.) to a K2 process, there is often a need to make modifications to the external component which requires that you update the reference in the K2 process. To do this you must remove and re-add the reference via the Process References dialog in the K2 Designer for Visual Studio or K2 Studio, then redeploy the process. See the Managing K2 Process References KB article for additional details.

This inevitably leads to the question of “Which version the referenced component will my K2 process instances use?” The answer of course is “It depends”.

When you add a reference to a K2 process and use the Copy Local option:

The assembly will be copied to the bin directory of the K2 Project and will get deployed to the K2Server database when you deploy the process. When you start a new instance of the process, the referenced assembly associated with the version of the process definition on which the instance was started will be used.

To illustrate how this works, the first time you start a process instance after the K2 service has been restarted, a temporary working folder will get created (one per process definition) and the assemblies associated with the version of the process definition on the which the instance was started will be extracted to a temporary folder at runtime. The temporary folders always reside in the \K2 blackpearl\Host Server\bin\Work directory. In this example you can see that BCExternalAssembly.dll resides in the temporary \Proc30 folder since the Copy Local checkbox was checked when the reference was added to the process:

When you need to maintain specific versions of an external reference that are associated with specific versions of a process definition, Copy Local should be used.

What if you don’t check the Copy Local checkbox?

If you don’t use the Copy Local option, the referenced component will not get copied to the bin directory of the K2 project and will not get deployed to K2. In this case you must manually copy the assembly to the GAC or the \K2 blackpearl\Host Server\bin directory on all of the K2 server(s). Any time the assembly is updated you will need to update it on the K2 server(s) and restart the K2 service.

If you have existing versions of a process definition that include a local copy of a referenced component and you deploy a new version of the referenced component to the GAC or \K2 blackpearl\Host Server\bin folder, the component deployed to the GAC or bin directory will get used for all versions of the process definition after the K2 service has been restarted. If a \K2 blackpearl\Host Server\bin\Work\Procxx temporary directory already exists for a particular version of the process the “local copy” of the component will continue to be used until the K2 Service is restarted.

On startup of the K2 service all of the temporary folders under the \Work folder will be deleted and external references for all versions of a process definition be loaded in the following order of precedence:

1. Global Assembly Cache

2. \K2 blackpearl\Host Server\bin directory

3. \K2 blackpearl\Host Server\bin\Work\Procxxx directory

For any version of a process definition with references where Copy Local was used, the referenced components will always get extracted to the temporary folder on the K2 server, but the above order of precedence still applies. In other words, don’t assume that because you see a referenced component in the temporary folders on the K2 server that the process definition is using it.

Storing the multiple user accounts from InfoPath to SharePoint

chrisg — Mon, 23 Apr 2012 18:32:00 GMT

This is a post about storing the data from an InfoPath Contact Selector control into SharePoint, in a proper way without coding.

It is very useful that when you have a K2 workflow with an InfoPath form, you want to store or synchronize the form data with a SharePoint item. I ran into an issue with saving multiple user accounts from a Contact Selector control. All accounts entered in this InfoPath control must be saved with the corresponding SharePoint item. When the user submits the form K2 must update the metadata of the SharePoint item.

For example: imagine that your InfoPath form contains a Contact Selector in which multiple user accounts may be added, like in the screenshot below.

You want to store the user accounts (Bremen, Onderwater, Schepers) with the SharePoint list item, like in the screenshot below.

By default, it looks like this is not possible but I have found something that can do the trick. And the best thing: no coding is needed!

In you are familiar with the Contact Selector you know that InfoPath has the following fields in the main data source (a Person group that contains the nodes DisplayName, AccountId, AccountType). If you do not know how to configure the Contact Selector, please read the following page: http://msdn.microsoft.com/en-us/library/ms558892.aspx.

In SharePoint you need to create a column to store the user accounts. In my example I name this column 'Experts'. Please note that you need to switch on the 'Allow multiple selections' option.

Now you go to your K2 workflow and you create two activities (at this point the magic happens).

For the first activity, 'Extract experts', plan the Destination Users according the options below:

- Run this wizard in Advanced Mode

- Plan per destination - All at once

- Create a slot for each destination

- Resolve all roles and groups to users

- Add a destination set with the AccountId node of the InfoPath Contact Selector

Create a data field of the type String. In my example I name this field 'Experts'.

Add a Data Event to the first activity. This Data Event fills the data field 'Experts' with all user accounts in the Contact Selector.

To do this you will need the following formula:

In the second activity, 'Save experts', add a SharePoint List Items event. Configure this event to save the Data Field Experts to the SharePoint Experts column.

As you probably have noticed, the first activity loops through all InfoPath AccountId nodes and appends them to the Experts data field. The second activity just stores the value of this data field in the SharePoint metadata column. Easy like that!

This was a guest post written by Jordy van Bremen from Opendocs

Updating an InfoPath Form after a Client Event

JohanL — Mon, 16 Apr 2012 15:05:35 GMT

From within a K2 Process the fields from an InfoPath form can be updated by accessing the InfoPath XML Field from the K2 Object Browser.

When trying to do this from within an activity containing an InfoPath client event, you will find that your changes are not being persisted to the InfoPath form when the activity completes. This happens because each destination user gets their own copy of the InfoPath XML which they interact with at an Activity Instance level. When the activity completes, the XML is copied back to the Process-level XML field. When you have a data event in the same activity as an InfoPath Client Event, use the Activity-level XML field values when trying to read/write to the InfoPath form. This ensures that when the activity completes, your changes are persisted to the InfoPath form when the next person opens their InfoPath form.

You only need to do this on any event after a InfoPath Client Event, just before an InfoPath Client Event or in an activity without any InfoPath Client Events you should continue using the Process XML field.

Happy Designing!

JohanL

Talking Workflow with Virgil Carroll

chrisg — Mon, 12 Mar 2012 14:48:00 GMT

Our latest podcast on talking workflow we are luck enough to have Virgial Carroll join us. Virgil is regularly out there speaking and evangilizing the beneftis of SharePoint and this week sits down with us to talk about workflow and business processes. Virgil runs High Monkey consulting http://www.highmonkey.com/ and can be found on twitter at http://twitter.com/vcmonkey or you can read his blog here http://monkeyblog.highmonkey.com

Talking workflow with Tim Knechtel

chrisg — Tue, 28 Feb 2012 17:24:00 GMT

In this edition of Talking workflow we are joined by Tim Knechtel. Tim is an Insider and Principal Technologist with Caprivi Solutions

Talkin workflow with Ruben D'arco

chrisg — Mon, 13 Feb 2012 20:32:00 GMT

This week in talkin workflow we are talking with Ruben D'arco. Ruben is a former insider and most recently started working for our K2 Northern Europe Distributorship. In Ruben's diverse experience he has gained some very good insight into workflow and the use of K2 overall. This podcast is definitely worth a listen. You can find Ruben on twitter at http://twitter.com/_cyclops_ or on his blog at http://cyclops.nettrends.nl/blog/

K2 Underground

Using K2 connect 4.6.5 deserialize/serialize functionality in K2 smartforms

K2 smartform Tips: Using the Transfer Data Rule

K2 smartforms 1.0.2 is out!

Setting up a secondary K2 smartform runtime site for anonymous access

Working with Onboarding and K2

Deploying the Silverlight package to users using a GPO

VMWare Workstation Long Shutdowns or odd pauses

K2 Tip of the Day : When to use IPCs?

K2 XML Fields and XML Schemas

XML Schema

Access SQL Server Information for a K2 process Part 2

Consolidating Views

K2 4.6.1 Tip of the Day : ADUM Logging

Access SQL Server Information for a K2 process Part 1

How to Automate Document Assembly from within a K2 Process

Using Linq for XML in K2

How to Write a Generic K2 Helper Class

Integrating K2 Client Events with Dynamics CRM 2011 using K2 Services

Scenario

K2 Services

Customize Dynamics CRM 2011 – Part 1

K2OnPageLoad

Show the K2 tab on the form that to this point has been hidden

K2OnPageSave

Dynamics CRM 2011 Forms URL

Building the Process

Testing our Process

Conclusion

Appendix – K2.Demo.CRM.LeadDemo.js

K2 SmartActions

What is SmartActions anyway?

A practical example

Behind the magic

Mail server integration

Enabling Actions to be SmartActions-enabled

Task notification design

Configuring SmartAction Synonyms

Customization of response templates

Applying SmartActions to current Processes

Wrapping up

K2 and SSIS

3. How TO Best use ADO.NET SOURCE EDITOR (ADO Queries)

Understanding how K2 Project References are used

Storing the multiple user accounts from InfoPath to SharePoint

Updating an InfoPath Form after a Client Event

Talking Workflow with Virgil Carroll

Talking workflow with Tim Knechtel

Talkin workflow with Ruben D'arco