Stand-alone scripts for Smart Office

Here is a solution to write stand-alone scripts for Smart Office. Stand-alone scripts are interesting to create mini applications in Smart Office like widgets, or to create full blown applications like composite applications.

A stand-alone script runs independently of an M3 program, in its own instance, eventually with its own user interface. Whereas a regular script runs as part of an M3 program, for example inside CRS610.

I will illustrate how to write a stand-alone script by creating a Tiling Window Manager widget. It’s a continuation of my previous post on How to tile windows in Smart Office. The result will look like this:

Make sure to read my disclaimer before trying this as I’m using non-public APIs.

First, I will create an empty window with an icon in the Taskbar:

var task = new Task(new Uri('jscript://'));
task.VisibleName = 'Hello World';
var runner = DashboardTaskService.Current.LaunchTask(task, null);
runner.Status = RunnerStatus.Running;
var host = runner.Host;
host.HostTitle = 'Hello World';
host.Show();

The result will look like a regular Smart Office window, albeit empty:

Then, I will use HostType.Widget to change the appearance of the window and make it look like a small widget:

var task = new Task(new Uri('jscript://'));
task.AllowAsShortcut = false;
task.VisibleName = 'Tiling Window Manager';
var runner = DashboardTaskService.Current.LaunchTask(task, HostType.Widget);
runner.Status = RunnerStatus.Running;
var host = runner.Host;
var wrapPanel = new WrapPanel();
host.HostContent = wrapPanel;
host.HostTitle = 'Tiling Window Manager';
host.ResizeMode = ResizeMode.NoResize;
host.Show();
host.Width = 221;
host.Height = 85;

The host’s Width and Height must be set after host.Show().

The result will look like a widget:

Then, I will add three buttons to the widget:

var buttons: String[] = [' ← ''Tile'' → '];
for (var i in buttons) {
    var btn = new Button();
    btn.Content = buttons[i];
    btn.Width = double.NaN; // auto width
    btn.Margin = new Thickness(3, 0, 3, 0); // ltrb
    btn.Padding = new Thickness(7, 0, 7, 0); // ltrb
    wrapPanel.Children.Add(btn);
}
wrapPanel.HorizontalAlignment = HorizontalAlignment.Center;

The result will finally look like the desired widget:

Then, I will add an event handler for the buttons:

btn.add_Click(OnClick);
...
function OnClick(sender: Object, e: RoutedEventArgs) {
    if (sender.Content.Equals(' ← ')) {
        //
    } else if (sender.Content.Equals('Tile')) {
        //
    } else if (sender.Content.Equals(' → ')) {
        //
    }
}

Then, I will add the functions for tiling and shifting the visible windows horizontally on the screen.

var shift = 0;
...
/*
 Tiles the specified windows horizontally accross the screen.
*/
function tileInstances(instances: ArrayList) {
    this.shift = 0;
    for (var i = 0; i < instances.Count; i++) {
        tileInstance(instances[i], i, instances.Count);
    }
}
/*
 Shifts the specified windows horizontally, to the left or to the right.
*/
function shiftInstances(instances: ArrayList, increment: int) {
    this.shift += increment;
    for (var i = 0; i < instances.Count; i++) {
        var n: int = instances.Count;
        var j: int = (((i + this.shift) % n) + n) % n; // fix the JavaScript modulo bug
        tileInstance(instances[i], j, instances.Count);
    }
}

Then, I will deploy the script on the server.

For Grid installations the deploy folder is somewhere like:

\\hostname\d$\Lawson\LifeCycleManager\Service\XYZ\grid\TST\applications\LSO_M3_Adapter\webapps\mne\jscript\

For non-Grid installations the deploy folder is somewhere like:

\\hostname\d$\IBM\WebSphere7\AppServer\profiles\MWPProfile\installedApps\MWPProfileCell\MWP_EAR.ear\MNE.war\jscript\

Then, I will add a shortcut to the Smart Office Canvas to launch the script with this special syntax:

mforms://_runscript?name=TilingWindowManager

My final script is:

import System;
import System.Collections;
import System.Windows;
import System.Windows.Controls;
import Mango.Services;
import Mango.UI.Core;
import Mango.UI.Services;
import MForms;
import Mango.UI;

/*
	Thibaud Lopez Schneider
	Infor
	May 7, 2012

	This script opens a widget to tile and shift the visible windows horizontally in Smart Office.
*/

package MForms.JScript {
	class TilingWindowManager {
		var shift = 0;
		public function Init(element: Object, args: Object, controller : Object, debug : Object) {
			try {
				var task = new Task(new Uri('jscript://'));
				task.AllowAsShortcut = false;
				task.VisibleName = 'Tiling Window Manager';
				var runner = DashboardTaskService.Current.LaunchTask(task, HostType.Widget);
				runner.Status = RunnerStatus.Running;
				var host = runner.Host;
				host.HostContent = CreateWindow();
				host.HostTitle = 'Tiling Window Manager';
				host.ResizeMode = ResizeMode.NoResize;
				host.Show();
				host.Width = 221;
				host.Height = 85;
			} catch(ex: Exception) {
				ConfirmDialog.ShowErrorDialogWithoutCancel(ex.GetType(), ex.Message + '\n' + ex.StackTrace, null);
			}

		}
		function CreateWindow() {
			var wrapPanel: WrapPanel = new WrapPanel();
			var buttons: String[] = [' ← ', 'Tile', ' → '];
			for (var i in buttons) {
				var btn = new Button();
				btn.Content = buttons[i];
				btn.Width = double.NaN; // auto width
				btn.Margin = new Thickness(3, 0, 3, 0); // ltrb
				btn.Padding = new Thickness(7, 0, 7, 0); // ltrb
				wrapPanel.Children.Add(btn);
				btn.add_Click(OnClick);
			}
			wrapPanel.HorizontalAlignment = HorizontalAlignment.Center;
			return wrapPanel;
		}
		/*
			Returns a list of the visible windows.
		*/
		function getVisibleInstances() {
			var instances = MainController.Current.GetInstances();
			var visibleInstances = new ArrayList();
			for (var instance in instances) {
				var window: EmbeddedHostWindow = instance.Host.Implementation;
				if (window.Visibility == Visibility.Visible) {
					visibleInstances.Add(instance);
				}
			}
			return visibleInstances;
		}
		/*
			Tiles the specified window at the specified index relative to the specified count of windows.
		*/
		function tileInstance(instance: InstanceController, i: int, count: int) {
			var window: EmbeddedHostWindow = instance.Host.Implementation;
			window.Width = instance.ParentWindow.Width / count;
			window.Height = instance.ParentWindow.Height;
			DashboardService.Window.SetPosition(new Point(window.Width * i, 0), window);
		}
		/*
			Tiles the specified windows horizontally accross the screen.
		*/
		function tileInstances(instances: ArrayList) {
			this.shift = 0;
			for (var i = 0; i < instances.Count; i++) {
				tileInstance(instances[i], i, instances.Count);
			}
		}
		/*
			Shifts the specified windows horizontally, to the left or to the right.
		*/
		function shiftInstances(instances: ArrayList, increment: int) {
			this.shift += increment;
			for (var i = 0; i < instances.Count; i++) {
 				var n: int = instances.Count;
 				var j: int = (((i + this.shift) % n) + n) % n; // fix the JavaScript modulo bug
 				tileInstance(instances[i], j, instances.Count);
 			}
 		}
 		/*
 			Handles the click on the buttons.
 		*/
 		function OnClick(sender: Object, e: RoutedEventArgs) {
 			try {
 				var visibleInstances = getVisibleInstances();
 				if (visibleInstances.Count > 0) {
					if (sender.Content.Equals(' ← ')) {
						shiftInstances(visibleInstances, -1);
					} else if (sender.Content.Equals('Tile')) {
						tileInstances(visibleInstances);
					} else if (sender.Content.Equals(' → ')) {
						shiftInstances(visibleInstances, +1);
					}
				}
			} catch(ex: Exception) {
				ConfirmDialog.ShowErrorDialogWithoutCancel(ex.GetType(), ex.Message + '\n' + ex.StackTrace, null);
			}
		}
	}
}

Voilà!

This solution showed how to create a stand-alone script in Smart Office, how to create a widget-like script, and how to tile and shift windows.

If you liked this solution, I invite you to subscribe to this blog.

Special thanks to Peter A.J. for the original help.

How to tile windows in Smart Office

Here is a solution to tile M3 programs in Smart Office. It is a Tiling window manager for Smart Office with automatic scaling, placement, and arrangement of windows, for example to organize M3 programs horizontally across the screen.

This solution is useful for example to put side by side two programs that a user might often use, for example Customer Order. Open Toolbox – OIS300 to see all the orders in M3, and Batch Customer Order. Open – OIS275 to see problems with those orders. A user might want to put the two windows side by side to monitor the orders. If a user does that every day, she might want a solution to tile the programs automatically. This solution will enhance the user experience and will contribute to increase user productivity.

First, we get a reference to the window with:

var window = controller.Host.Implementation; // Mango.UI.Services.EmbeddedHostWindow

Then, we de-iconify the window with:

window.ActivateWindow(true);

Then, we scale the window in pixels, for example:

window.Width = 1280;
window.Height = 800;

Then, we scale the window relative to the main Smart Office window – which is given by controller.ParentWindow – for example to half the width and full height of the screen:

window.Width = controller.ParentWindow.Width / 2;
window.Height = controller.ParentWindow.Height;

Then, we position the window horizontally and vertically in pixels on the screen by using Mango.UI.Services.DashboardService, for example:

DashboardService.Window.SetPosition(new Point(100, 20), window); // x, y

Then, we get a list of the M3 programs that are currently running – we use MainController for that – and we get a reference to each window:

var instances = MainController.Current.GetInstances(); // System.Collections.Generic.IList<IInstanceController>
for (var i: int = 0; i < instances.Count; i++) {
    var controller_: Object = instances[i]; // MForms.IInstanceController
    var window = controller_.Host.Implementation;
}

If we want to tile the windows horizontally, we scale each window’s width respective to the total number of windows. For example, if there are three windows on the screen, each window will occupy a third of the screen:

window.Width = controller_.ParentWindow.Width / instances.Count;
DashboardService.Window.SetPosition(new Point(window.Width * i, 0), window);

If we want to tile two specific M3 programs, we can find them by their name, and tile them accordingly. For example, here I position OIS275 to the left, and OIS300 to the right:

var name = controller_.RenderEngine.PanelHeader;
if (name.Equals('OIS275/B1')) {
    DashboardService.Window.SetPosition(new Point(0, 0), window); // leftelse if (name.Equals('OIS300/B')) {
    DashboardService.Window.SetPosition(new Point(controller_.ParentWindow.Width - window.Width, 0), window); // right
}

Here is my full source code to automatically tile all the windows horizontally:

import System.Windows;
import Mango.UI.Services;
import MForms;

package MForms.JScript {
	class TileHorizontally {
		public function Init(element: Object, args: Object, controller : Object, debug : Object) {
			var instances = MainController.Current.GetInstances(); // System.Collections.Generic.IList
			for (var i: int = 0; i < instances.Count; i++) {
				var controller_: Object = instances[i]; // MForms.IInstanceController
				var name = controller_.RenderEngine.PanelHeader; // M3 program name
				var window = controller_.Host.Implementation; // Mango.UI.Services.EmbeddedHostWindow
				window.ActivateWindow(true); // de-iconify
				window.Width = controller_.ParentWindow.Width / instances.Count; // set width to a respective fraction of the screen
				window.Height = controller_.ParentWindow.Height; // set to full height
				DashboardService.Window.SetPosition(new Point(window.Width * i, 0), window); // position
			}

		}
	}
}

Here is a screenshot of the result that shows three windows tiled horizontally. It’s just for illustration purposes as the windows look crowded with my low resolution screen; in a real scenario two windows or a bigger screen would look better.

Voilà!

If you liked this solution, I invite you to subscribe to this blog.

Also, read the follow-up to this post with Stand-alone scripts for Smart Office where I convert this Tiling Window Manager into a widget-like script.

Special thanks to Karinpb for the help.

Compiled Scripts for Smart Office

Here is a solution in Lawson Smart Office to write “compiled scripts” in C# (as opposed to writing dynamic scripts in JScript.NET).

Background

Traditionally, Personalized Scripts for Lawson Smart Office are written with the built-in Script Editor in the JScript.NET programming language and are deployed as plain text *.js files on the server.

There is also a less known technique. It is also possible to write scripts in C#, to compile them as DLL, and to deploy the *.dll file in lieu of the *.js file.

Pros and cons

There are several advantages of using C# versus JScript.NET. Mostly, the biggest advantage is the full richness of C#. Indeed, C# supports features that are not supported in JScript.NET, for example delegates. Also, C# is more extensively supported by Microsoft and by the community. Whereas JScript.NET is not fully supported by Microsoft, for example there’s no IntelliSense for JScript.NET in Visual Studio whereas there is IntelliSense for C#, and there are almost no examples for JScript.NET in MSDN whereas there are plenty for C#.

There are several disadvantages of using C# versus JScript.NET. Developing compiled scripts requires compiling the C# source code and deploying the DLL to run the script, which makes each iteration longer than developing with JScript.NET. Also, from the deployed DLL it’s not possible to directly see the source code, which is a problem if the source code is not available. Also, the script might need to be re-compiled for different versions of Smart Office, which could be a problem with upgrades.

Microsoft Visual C# Express

I will use Microsoft Visual C# Express to develop and compile my source code.

1) Find the Smart Office libraries

First, we need to find the Smart Office DLL as we’ll need to reference them in Microsoft Visual C# Express.

A user’s computer can run multiple instances of Smart Office at the same time, with different LSO version numbers, and different DLL version numbers. We want to find the correct DLL for our desired instance of Smart Office. There are two sets of DLL to find:

  1. Go to Smart Office
  2. Open the Help menu, it’s the question mark icon at the top right
  3. Select About Lawson Smart Office:
  4. Select View log file:
  5. That will open the Log Viewer
  6. Filter by message C:\ . That will show you the path to the Smart Office ClickOnce deployment folder in your computer, for example:
  7. C:\Users\12229\AppData\Local\Apps\2.0\Data\79O176HR.9F1\N42AOMBD.0HB\http..tion_2b27e2947dd74766_000a.0000_20a2b87dbe5264e8\
  8. Open that folder in Windows Explorer
  9. Search for the DLL files in all sub-folders. That will give us the first set of DLL, for example:
  10. The second set of DLL files is located in the other branch of the folder structure at C:\Users\12229\AppData\Local\Apps\2.0\. For example:
    C:\Users\12229\AppData\Local\Apps\2.0\3YDTAV5W.D22\Q01ZYJYU.RV0\http..tion_2b27e2947dd74766_000a.0000_20a2b87dbe5264e8\

2) Create a Project

Now that we found the two sets of DLL files we can create a C# project in Visual C# Express and reference the DLL.

  1. Go to Visual C# Express
  2. Select File > New Project
  3. Select Class Library and give it a Name:
  4. Select Project > Properties, and make sure to use the same Target framework as your target Smart Office; for example, I use .NET Framework 4.0:
  5. Select Project > Add Reference:
  6. Browse to the first set of DLL found above:
  7. Then add the second set of DLL:
  8. Add the .NET components PresentationCore and PresentationFramework:
  9. Add System.Xaml:
  10. Add WindowBase:
  11. Select File > Save All, and choose a location to save your project.

3) Type the source code

Now we can start creating our script:
using System;
using System.Windows;
using System.Windows.Controls;
using MForms;
using Mango.UI;

namespace MForms.JScript
{
    public class Thibaud
    {
        public void Init(object element, object args, object controller, object debug)
        {
        }
    }
}

The result will look like this:

4)  Compile

Select Debug > Build Solution:

Visual C# Express will compile the code and produce a DLL file in the \obj\Release\ sub-folder of your project:

5) Deploy

Locate the jscript folder.

For Grid versions of Smart Office, the jscript folder is located in one of the LifeCycle Manager sub-folders, for example:

\\hostname\d$\Lawson\LifeCycleManager\Service\<service>\grid\<profile>\applications\LSO_M3_Adapter\webapps\mne\jscript\

For non-Grid versions of Smart Office, the jscript folder is located in one of the WebSphere sub-folders, for example:

\\hostname\d$\IBM\WebSphere7\AppServer\profiles\MWPProfile\installedApps\MWPProfileCell\MWP_EAR.ear\MNE.war\jscript\

And copy/paste your DLL file there:

6) Execute

Now that the script is deployed on the server, we can execute it:

  1. Attach the script to the desired panel in Smart Office via Tools > Personalize > Scripts
     
  2. Set the Script value to the filename and .dll extension, for example Thibaud.dll:
  3. Click Add
  4. Click Save
  5. Press F5 to load and execute the script

7) Additional source code

If you need the controller, you will need to cast it from object to MForms.InstanceController.

InstanceController controller_ = controller as InstanceController;

If you need the content, you will need to cast it from object to System.Windows.Controls.Grid.

Grid content = controller_.RenderEngine.Content;

Now you can start developing your scripts, for example:

TextBox WRCUNM = ScriptUtil.FindChild(content, "WRCUNM") as TextBox;
controller_.RenderEngine.ShowMessage("The value is " + WRCUNM.Text);

Here is a screenshot of my sample script:

UPDATE 2012-04-25: Wayne L. found that we can also use a strongly typed signature for the Init method, so we don’t have to cast the objects anymore:

public void Init(object element, String args, MForms.InstanceController controller, MForms.ScriptDebugConsole debug) {
}

Voilà!

Thanks to Peter A.J. for the help.

How to call a process flow from a Smart Office script

Here is a solution to trigger ProcessFlow Integrator (PFI) from a Personalized Script for Lawson Smart Office (LSO) using the native PF adapter. This technique is new as of LSO 9.1.3.

First, enable the PF configuration in the Smart Office Profile Editor:

Then, use Lawson.Shared.PF.Trigger to determine if Trigger Services are available:

if (PFTrigger.HasTriggerService) {
    // Trigger Services are available
} else {
    // Trigger Services are not available
}

PFTrigger is part of Lawson.Shared.dll:

Then, prepare the trigger:

var service = 'MyService';
var product = 'ERP';
var dataArea = 'PFTST';
var category = '';
var title = 'Test from a script';
var trigger = new PFTrigger(service, product, dataArea, category, title);
trigger.AddVariable('var1''Hello1''String');
trigger.AddVariable('var2''Hello2''String');
trigger.AddVariable('var3''Hello3''String');

Then, execute the trigger:

trigger.SubmitRequest(dataArea, OnTriggerCompleted);

Then, add an event handler:

function OnTriggerCompleted(args: PFTriggerEventArgs) {
    if (args != null && args.IsSuccessful) {
        args.Response.DetailMessage
        args.Response.ErrorCode
        args.Response.InformationCode
        args.Response.ReturnCode
        args.Response.ReturnData
        args.Response.Status
        args.Response.WorkunitNumber
    }
}

Here’s a screenshot of the result:

We can see the HTTP Request and Response with Fiddler:

For versions of Smart Office prior to 9.1.3, it’s possible to trigger PF flows using the old technique with URL. For that, you can use the PFI trigger generator.

The advantage of the new technique is the lower number of lines of code, increased readability, no need to hard-code the hostname, port, user, and password anymore, and no need to handle authentication nor logout.

 

That’s it!

How to tell Mashups apart in a Smart Office script

Here is a solution to tell in which Mashup a Personalized Script for Lawson Smart Office is currently running, for example to tell Mashups A and B apart in a script. We’ll read the BaseUri and Uri properties of a MashupInstance.

This solution is useful in scenarios where we have two Mashups, each with a specific script attached to a common M3 program. Each script needs to tell in which Mashup it’s currently running as we don’t want to let the scripts run in the wrong Mashup.

Example

For example, I have two Mashups that both use the M3 program Item Toolbox – MMS200.

The first Mashup (MashupA) shows a list of items and detailed information about a selected item, such as shelf-life, buyer’s name, on-hand availability in all warehouses, lot information, etc. In this Mashup, we need a script (ScriptA) to append an additional column of information to the list of items by querying a third-party warehouse management system. This Mashup is useful for the sales team to accurately communicate detailed information to a customer on the phone to convert a potential customer order and get the sale.

The second Mashup (MashupB) shows a list of items and purchasing information about a selected item, such as demand, supply, inventory, item specifications, sales history, forecast, etc. In this Mashup, we need a script (ScriptB) to append an additional column of information to the list of items by querying a third-party purchasing order software. This Mashup is useful for the purchase planning process when buyers need to decide if to buy an item or not and create a purchase order.

Both Mashups A and B have the same M3 program MMS200 in common, and two different scripts A and B. Each script needs to execute in its corresponding Mashup, script A in Mashup A, and script B in Mashup B. Otherwise, the scripts would show the wrong information in the wrong Mashup.

Problem

The problem is that when we attach a script to an M3 program in Smart Office, we cannot tell for which Mashup to execute the script. We can only attach the script to an M3 program, in my case to MMS200/B, and then attach the M3 program to the Mashup. But that doesn’t tell the script which Mashup is which.

More generally, Smart Office can only do binary relationships Mashup-Program and Program-Script, whereas we need ternary relationships Mashup-Program-Script. We are trying to solve that problem.

Solution

The solution is to get the identifier of the Mashup. Actually we cannot get the identifier of the Mashup as is defined in the Project’s manifest file. But we can derive one from a combination of the path of the Mashup, for example Mashups\MashupA.mashup, and the filename of the XAML, for example MashupA.xaml. That’s given by the Mashup’s BaseUri and Uri respectively.

For that, we’ll start with karinpb‘s solution to check if a JScript is running in a Mashup.

var element = controller.RenderEngine.ListControl.ListView;
var type = Type.GetType("Mango.UI.Services.Mashup.MashupInstance,Mango.UI");
var mashup = Helpers.FindParent(element, type);

That gives us a object that we can cast to MashupInstance from which we can get the  BaseUri and Uri properties:

mashup.BaseUri // ex: Mashups\MashupA.mashup
mashup.Uri // ex: MashupA.xaml

Here is a screenshot of the Smart Office SDK documentation:

Here’s my sample source code:

import System;
import Mango.UI.Services.Mashup;
import Mango.UI.Utils;

package MForms.JScript {
    class Test {
        public function Init(element: Object, args: Object, controller : Object, debug : Object) {
            if (controller.PanelState.IsMashup){
                var mashup: MashupInstance = Helpers.FindParent(controller.RenderEngine.ListControl.ListView, MashupInstance);
                switch (mashup.BaseUri + "\\" + mashup.Uri) {
                    case "Mashups\\MashupA.mashup\\MashupA.xaml": debug.WriteLine("MashupA"); break// MashupA
                    case "Mashups\\MashupB.mashup\\MashupB.xaml": debug.WriteLine("MashupB"); break// MashupB
                    case "Mashups\\MashupC.mashup\\MashupC.xaml": debug.WriteLine("MashupC"); break// MashupC
                    default: debug.WriteLine("Mashup not supported"); // Mashup not supported
                }
            } else {
                // Not in Mashup
                debug.WriteLine("Not in Mashup");
            }
        }
    }
}

Here are screenshots of the result:

Thanks to karinpb, Peter K, and Joakim I for their help.

That’s it!

How to get the user password in a Smart Office script

Here is a solution to get the Lawson Smart Office user’s password with a Personalized Script.

This solution is interesting in scenarios where at runtime we need the current user’s password to dynamically integrate to external systems, for example to connect to a network drive, to connect to a secure website, to execute SQL, to call web services, etc. Also, this solution is interesting to call M3 API or to trigger PFI flows for early versions of Lawson Smart Office that don’t have those native adapters; late versions of Smart Office have native adapters to call M3 API and to trigger PFI flows without the need to obtain the user’s password.

Follow this link to Geiger’s blog to see the solution: How to get the user password in a Smart Office script.

Dependency graphs for data conversion

Dependency graphs show the relationships between M3 programs – how they relate to one another – and are useful during data conversion. In this article I discuss their benefits and how to create them.

Background

Data conversion is the process of transferring data from the customer’s legacy system into M3 with tools such as M3 API, M3 Data Import (MDI), Lawson Web Services (LWS), and Lawson Smart Data Tool (SDT) during the implementation project.

Relationships between programs are governed by M3. The M3 Business Engine ensures the integrity of its programs. For example, to create a Warehouse – MMS005 we need to create a Facility – CRS008, to create a Facility we need to create a Division – MNS100, to create a Division we need to create a Company – MNS095, and so on.

Dependency graphs

Dependency graphs show the relationships between M3 programs in a graphical form, as illustrated in the following subset of a larger graph:

Benefits

Dependency graphs are useful during data conversion for various reasons:

  • They visually provide a lot of information with little cognitive effort
  • They help delimit the scope, and help quantify the amount of work
  • They dictate the order in which to proceed
  • They help build the project plan, and help estimate the duration

Dependencies

Smart Data Tool comes with Configuration Sheets that contain a curated list of M3 dependencies. It’s one of the best sources of dependencies available.

The following screenshot shows the Configuration Sheet for Item – MMS001 where column G tells which programs we need to setup before we can create an Item – MMS001:

Dependencies extraction

We can programmatically extract the dependencies from the Smart Data Tool Configuration Sheets by reading the Excel files with ODBC/JDBC, or with Excel libraries available on the Internet (Java, VB, .NET, PHP, etc.).

Graph production

From those dependencies, we can automatically generate dependency graphs using tools such as Graphviz – an open source graph visualization software – in the DOT language.

Here is a subset of the dependency graph for Customer Addresses – OIS002:

digraph g {
 CRS070 -> OIS002;
 CRS065 -> OIS002;
 OIS002 [label="Customer Addresses\nOIS002"];
 CRS070 [label="Delivery method\nCRS070"];
 CRS065 [label="Delivery terms\nCRS065"];
}

Visualization

We can visualize large graphs in an easy zoomable way with a tool like ZGRViewer.

Conclusion

Dependency graphs greatly facilitate the data conversion effort. We can generate them programmatically with a combination of tools including Lawson Smart Data Tool and the open source Graphviz.

That’s it!

How to get the URL to Lawson Web Services in a Mashup

Here’s a technique for a Mashup to call a Lawson Web Service (LWS) using the correct Lawson Web Service server and the correct environment (DEV, EDU, PRD, TST, etc.).

The problem

By default, when we use the Web Service wizard in Mashup Designer, the URL to the Lawson Web Service server is hard-coded in the two Parameters WS.Wsdl and WS.Address.

For instance, in the following example we’re using a Lawson Web Service that calls the M3 API CRS610MI.LstByNumber, but the server (hostname), the port number (10000), and the environment (TST) are hard-coded in the URL:

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:ui="clr-namespace:Mango.UI.Controls;assembly=Mango.UI" xmlns:mashup="clr-namespace:Mango.UI.Services.Mashup;assembly=Mango.UI">
    <mashup:DataPanel Name="WS">
       <mashup:DataPanel.Events>
          <mashup:Events>
             <mashup:Event SourceEventName="Startup" />
          </mashup:Events>
       </mashup:DataPanel.Events>
       <mashup:DataPanel.DataService>
          <mashup:DataService Type="WS">
             <mashup:DataService.Operations>
                <mashup:DataOperation Name="Read">
                   <mashup:DataParameter Key="WS.Wsdl" Value="http://hostname:10000/LWS_TST/svc/CRS610MI.wsdl" />
                   <mashup:DataParameter Key="WS.Address" Value="http://hostname:10000/LWS_TST/services/CRS610MI" />
                   <mashup:DataParameter Key="WS.Operation" Value="LstByNumber" />
                   <mashup:DataParameter Key="WS.Contract" Value="CRS610MI" />
                   <mashup:DataParameter Key="mws.user" Value="LSO.USER" />
                   <mashup:DataParameter Key="mws.password" Value="LSO.PASSWORD" />
                </mashup:DataOperation>
             </mashup:DataService.Operations>
          </mashup:DataService>
       </mashup:DataPanel.DataService>
    </mashup:DataPanel>
 </Grid>

Because the server and environment are hard-coded in the XAML, it will be difficult to deploy the Mashup on other servers, and on other environments (DEV, EDU, PRD, etc.). The workaround would be to make one copy of the Mashup per target server and per target environment. But it would quickly become a maintenance nightmare.

The goal is to make that URL dynamic, based on the server and on the environment we are currently running.

The solution

The solution is to dynamically read at runtime the URL to Lawson Web Services that’s defined in the Smart Office Profile:

Step 1 – Get the value

We get the URL to Lawson Web Services in the Mashup with:

{mashup:ProfileValue Path=M3/WebService/url}

For example:

Step 2 – Create a parameter

Then, we create an Event parameter with a SourceKey and the value, and we call it for example BaseUri:

<mashup:Event SourceEventName="Startup" >
    <mashup:Parameter SourceKey="BaseUri" Value="{mashup:ProfileValue Path=M3/WebService/url}" />
</mashup:Event>

Step 3 – Move it to an Event

Then, we move the two WS parameters from the DataPanel to the Event as TargetKeys:

<mashup:Event SourceEventName="Startup" >
    <mashup:Parameter SourceKey="BaseUri" Value="{mashup:ProfileValue Path=M3/WebService/url}" />
    <mashup:Parameter TargetKey="WS.Wsdl" Value="http://hostname:10000/LWS_TST/svc/CRS610MI.wsdl" />
    <mashup:Parameter TargetKey="WS.Address" Value="http://hostname:10000/LWS_TST/services/CRS610MI" />
</mashup:Event>

Step 4 – Variable substitution

Finally, we use Karin’s solution for variable substitution and markup extension to un-hard-code the URL:

<mashup:Event SourceEventName="Startup" >
    <mashup:Parameter SourceKey="BaseUri" Value="{mashup:ProfileValue Path=M3/WebService/url}" />
    <mashup:Parameter TargetKey="WS.Wsdl" Value="{}{BaseUri}/svc/CRS610MI.wsdl" />
    <mashup:Parameter TargetKey="WS.Address" Value="{}{BaseUri}/services/CRS610MI" />
</mashup:Event>

Final code

Here’s the resulting source code:

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:ui="clr-namespace:Mango.UI.Controls;assembly=Mango.UI" xmlns:mashup="clr-namespace:Mango.UI.Services.Mashup;assembly=Mango.UI">
    <mashup:DataPanel Name="WS">
       <mashup:DataPanel.Events>
          <mashup:Events>
             <mashup:Event SourceEventName="Startup" >
                <mashup:Parameter SourceKey="BaseUri" Value="{mashup:ProfileValue Path=M3/WebService/url}" />
                <mashup:Parameter TargetKey="WS.Wsdl" Value="{}{BaseUri}/svc/CRS610MI.wsdl" />
                <mashup:Parameter TargetKey="WS.Address" Value="{}{BaseUri}/services/CRS610MI" />
             </mashup:Event>
          </mashup:Events>
       </mashup:DataPanel.Events>
       <mashup:DataPanel.DataService>
          <mashup:DataService Type="WS">
             <mashup:DataService.Operations>
                <mashup:DataOperation Name="Read">
                   <mashup:DataParameter Key="WS.Operation" Value="LstByNumber" />
                   <mashup:DataParameter Key="WS.Contract" Value="CRS610MI" />
                   <mashup:DataParameter Key="mws.user" Value="LSO.USER" />
                   <mashup:DataParameter Key="mws.password" Value="LSO.PASSWORD" />
                </mashup:DataOperation>
             </mashup:DataService.Operations>
          </mashup:DataService>
       </mashup:DataPanel.DataService>
    </mashup:DataPanel>
</Grid>

Conclusion

With this solution we learned how to create a Mashup that calls a Lawson Web Service such that the Mashup will use the correct Lawson Web Service server and the correct environment (DEV, EDU, PRD, TST, etc.).

Maybe LPD should make this a native feature of Mashups so that developers don’t have to implement it themselves.

For more examples on how to call a Lawson Web Service from a Mashup, refer to Karin’s post.

That’s it!

Lawson Learning courses

Lawson Learning offers various courses for learning how to create Mashups and Scripts for Lawson Smart Office. To see the list of available courses:

  1. Go to http://www.lawson.com/
  2. Select Services > Course Listings:
  3. Select MyLawson.com:
  4. Login with your MyLawson.com account.
  5. Select the Education tab:
  6. Go to Search and Register for Training and click English:
  7. Click on Search to find a course:
  8. Search by keyword Mashup, or Script.

The courses will be listed alphabetically, for example:

  • Lawson Mashup Designer
  • Mashup Designer
  • Smart Office Personalized Script M3

That’s it!

UPDATE 2012-10-16: Alternatively, and more simply, you can go directly to http://inter.viewcentral.com/events/cust/default.aspx?cid=lawson

UPDATE 2012-12-05: The direct link seems to have moved to http://inter.viewcentral.com/events/cust/default.aspx?cid=lawson&pid=1