Manage 2000 Programming

Web Function Usage Tracking

2012-01-25T14:52:00.006-06:00

Previous releases have attempted to provide usage tracking beyond the standard IIS logging, but have not been all that useful. Manage 2000 release 7.3 provides better tracking by recording web function start events in the WEB_USAGE_LOG file within the UniData database where Manage 2000 reporting tools are available.

To enable tracking simply go to WEB.CONSTANTS screen 5 and turn it on.

Enter 'Y' to post WEB_USAGE_LOG records as web functions are run on this account. Enter 'N' to disable posting of log records. A null entry is treated the same as 'N'.

Control the purging of WEB_USAGE_LOG records through PURGE.CONTROLS. The purge type is WUL and the standard configuration is to purge back to the last 3 weeks once a month.

View log records through WEB.USAGE.

The standard functionality provides lots of identifiers, but if you want meaningful company and person names you will need to set up some I-Descriptors in the WEB_USAGE_LOG file and copy the WEB.USAGE REPORT.BUILD report from the MT library to your local library and add the fields you want.

Top Ten Things To Know on Manage 2000 7.3

2012-01-19T13:23:00.012-06:00

1. What preferences settings exist and how to set them globally, by role
2. How to turn on and use web function usage tracking
3. How to use web performance exception reporting
4. How to present different views to different roles
5. How to setup mobile access to Manage 2000
6. How to setup and externally facing portal
7. How to setup AR KPI dashboard displays
8. How to enable attachments in web portals
9. How to extend web portals by creating REPORT.BUILD functions as web functions
10. How to develop web functions with Visual Studio

I'll try to post on these topics over the coming weeks.

Web Preferences

Web preferences allow you to configure behavioral characteristics of Manage 2000 web sites. They can be set globally in WEB.CONSTANTS on screen 3. They can be set per role in the CNT.SYSTEM.REFS function. They can be set per user in screen 8 of CONTACTS.

Web Preferences are cached on a per user basis. To get preference changes to take effect you need to logoff your web session and start a new one. You can logoff the web session from the Welcome Portal or the My Account menu or by running WebLogoff from PWS.

The most sought after preference change has been turning off the autocomplete behavior in web functions which seems to annoy users more than help them. So in WEB.CONSTANTS on screen 3 add Preference Code 12 Minimum Length for Autofill and set the value to 999.

Preference 1 External Home Page controls what happens when a user logs off the website. You can use it to redirect them to your company web site. You can also set it to a value of ../../mt/login/login.aspx which redirects them to the web login page. This feels nice and somehow harmonic to end the session where it began.

Preference 9 M2k Home Page controls what happens when a user logs into the web site. Using this preference in CNT.SYSTEM.REFS and by selecting the appropriate web function name you can start your customers in the shopping cart when they login, while directing sales reps to select the customer they wish to represent as they login, and direct service reps in the service portal as they come in.

As a developer constantly testing web functions I particularly like 13 Use LK as Default set to Y. Which does pretty much what you would expect. If users often want to view in a web function what they were just accessing in PWS then they might like this too.

Explore other preferences using ?? in one of the web preferences prompts. To avoid disturbing other users you can test just on yourself by setting preferences in CONTACTS screen 8.

Some preferences are fairly obvious like 4 Items Per Page. Others are a bit more mysterious like 8 Page Smoothing which can be used on users with older version of IE to cut down on the screen flickering during postbacks.

A number of them like the ...PDF.. settings can be tested from the REPORT.BUILD report viewer, or HyperQuery functions like CustOpenSalesOrders which provide export links for PDF viewing.

I'll cover the mobile and attachments preference settings in later postings on those topics.

In Defense of the Multi-Value Database

2012-01-07T15:01:00.005-06:00

Reading Andrew E. Wade's chapter "Business Objects in Object Databases" of Andrew Carmichael's anthology of OO practitioners "Developing Business Objects" from 1997 I am struck by the parallels between the advantages of Object Oriented databases and Multi-Value databases over RDBMS for complex business modeling such as ERP systems.

RDBMSs provide a simple, flat, tabular view of all information. The user must map his application data structures, whatever they might be, into those tables. Other traditional database systems require similar mapping down to simple, flat records. The user must work at the level of only the table data structure and only a small set of simple operations (select,project,join). Now, if the application data structures is naturally simple and flat, and the application operations are also simple, this mapping is straightforward and not an issue. On the other hand, when the application structures and operations become complex, the RDMBS approach forces the user to deal with this directly.

An ODBMS offers the ability to model an application in terms of objects, which may have any user-defined structure and any user-defined operations. Applications that require nested structures, dynamically varying sized structures, many-to-many relationships, and complex operations can map these directly to objects. Not only is the support far more efficient, far faster at run time, but the user may work at higher levels of abstraction. Instead of translating the application down to records and tuples with joins, the user can work directly with objects such as customers or manufacturing processes, and the natural, application-defined operations on these. The result is easier and faster for the developer and the end user.
...
When to Use an ODMS
...
Second, if the application's information is complex and interconnected, an ODBMS can provide much better performance and ease of use. To contrast, if the information being modeled consists of simple, flat, fixed-length field, that fit nicely into tables, an RDMBS can be a fine fit. On the other hand, if the information contains complex structure, nested structures, dynamically varying sized structures, including images, audio, and video, all these can be represented directly as objects. Saving the need to translate not only eases the developer's load, but also eliminates the need to translate at run time, making it faster.

To some users, the interconnections in their information model are even more important. In an RDBMS, such relationships are represented by creating secondary data structures, foreign keys. At run time, the system searches down two tables, comparing key values, until it discovers two that match.This search-and -compare process is called a join, an it's the weak point of relational technology. Even with the help of indices, it's slow, and the bigger the database, the slower it gets. In an ODBMS, there is no need to create and manage secondary data structures... Referential integrity, a difficult issue in traditional database systems, comes along automatically and easily. Moreover, the traversal is direct, with no need to search or compare, resulting in performance that is orders of magnitude faster. The more relationships, the more the application will benefit from an ODMBS.

Although to my way of thinking the most critical advantage of Multi-Value databases is their elasticity. They accomodate change. And change is the greatest challenge to software development and software field operations.

One example of this is the ability to add domain specific vocabulary to a database in the field. The I-Descriptor feature in file dictionaries allows one (among other things) to describe how the system should retrieve a single foreign field. This is, effectively, a class definition for a field level join. Once defined the foreign sourced field may be used as if it were local for query and record selection purposes. Some users shy away from creating new custom dictionaries, but I see this as teaching the database how to be more useful to the users, how to be more functional in the users natural business vocabulary.

Some argue that Multi-Value is dead. I hear this mostly in context of sales and marketing. But the absolute dominance of the healthcare sector by Intersystem's Cache and its predecessor MUMPS would seem to contradict this assertion. Critics will point out that Cache is not Multi-Value, but it most certainly is NOT first normal! In fact, one can argue that the Multi-Value database design is a subset of Cache's architecture.

I would argue that the default Multi-Value Telnet based UI is the major problem for sales and marketing. Cache supports HTML as an immediate client protocol. This has been a conspicuously missing piece in U2 and other Multi-Value vendors offerings. While there are many ways to mix-in HTML client protocols such as UO, RBO, BlueFinity, or developing your own data components as we did on the Manage 2000 team, these all introduce tons of extra complexity. On most Multi-Value platforms there is no native MV Basic way to simply and directly code HTML UI's.

Out Of the Box Experience (OOBE Newbie New)

2011-10-26T14:15:00.004-05:00

Well the development cutoff of Manage 2000 7.3 sp3 is done. I have upgraded our build system and development web server to sp4 where 7.3 future development will happen, and created the views for patching sp3. Now I wait and wait and wait while Release Control readies installs for the field and customer sites slowly rollout new service pack upgrades or come on board from older major releases.

One of the areas I have been trying to enrich is the How To documentation on various web setup processes. I hope this combined with more appropriate Sales Rep and Customer menus and default role preferences will make setting up external access to Manage 2000 less daunting, and thereby give more Manage 2000 sites ROI justification for upgrading to the newest Manage 2000 release.

Imagine Sales Reps, Service Personnel, Buyers for customers at trade shows pulling out their IPhone, Droid, or IPad and interacting directly with your Manage 2000 site.

IE 9.0 Firefox 4,5,6... and counting and Chrome

2011-08-27T16:51:00.003-05:00

Manage 2000 7.3 sp3 is now building in development with IE9 compatibility in standards mode with HTML 5.0 support. WhooooooooooooHooooooooooooooooo!!!

Development is scheduled to continue till mid-October giving a nice cushion for alpha testing to clean up any construction debris. So things are looking good for 7.3 sp3.

I still need to spend some quality time with the roiScreenControl used in the web product configurator to implement the new scrolled set capability and make it cross browser compatible with Chrome and Safari. But other than that everything seems to be running well in IE9, Chrome, Firefox and Safari.

A nice side benefit of the IE9 project for 7.3 sp3 is that more of the mobile tools and applications slated for 7.4 will make an early appearance. The ESOP module in particular will start sporting a sleek mobile look with a sales product code browsing app with add to cart capability, and mobile formatted shopping cart and checkout pages.

Wizard's Work

2011-06-09T15:07:00.007-05:00

Manage 2000 7.4 development now includes a wizard that is capable of generating a maintenance web function with single valued fields and scrolled sets somewhat akin to PWS.

And there were a LOT of bytes in that elephant!

But the payback is a reduction in cost of writing web clients for Manage 2000 maintenance and posting functions, which we will leverage during the remainder of the standard system development cycle. And it will produce further payback as a tool for custom development projects.

The Manage 2000 tooling for the faux scrolled sets leverages the ajax validation, last keys, and prompt stack features of the roiTextbox and provides smooth keyboard navigation.

It takes just a few moments to select fields from a business transaction object and generate a working web function, which can be further enhanced and polished in Visual Studio.

ITouch'd Manage 2000

2011-03-08T17:34:00.008-06:00

Well the Manage 2000 7.4 web repository is finally branched and 7.4 only development can now be checked in. But one last web tools development project did make it into the 7.3 sp3 code base before the branch; MT/M2000Mobile/M2000Mobile.aspx provides navigation based on MENU.MASTER trees and DEMO/MobileStockStatusByLoc/MobileStockStatusByLoc.aspx which provides an example application to copy.

The idea is to build HTML, javascript, and CSS styles that mimic mobile applications, rather than building applications in proprietary environments one end-user device at a time. Using micro-frameworks like WebApp.Net one can build a web page that looks and feels like a mobile app although it runs in the browser.

Sp2 just went out the door so we won't be launching sp3 for awhile but it should be available in plenty of time for stocking stuffers.

iManage2000

2011-01-30T11:29:00.005-06:00

This last month I've been testing and researching issues related to accessing Manage 2000 web functions from IPhone and Android based mobile devices. Since these internet enabled devices include web browsers the basic ability to run Manage 2000 web functions is built right in.

However there are stumbling blocks to their usability. The most obvious problem is the small screen and the large complex pages of standard Manage 2000 web function pages. A little further examination reveals navigation problems in the drop down menus. These are rendered by Infragistics UltraWebMenu controls which do not work properly with WebKit based browsers. Another issue to consider is performance when accessing the net through slower connections. (How many G's are there in T1?)

So, though you can go the discount route and setup phone desktop buttons to target specific standard Manage 2000 web functions, a little more work can lead to a much better user experience.

The road map to a better user experience includes replacing the standard heading banner with a navigation app based on IUI, WebApp.Net, or Sencha Touch. The menus should still be administerable in MENU.BUILD, but the whole mobile menu tree would get loaded to the mobile browser as a multi-layer page with anchor navigation between layers. This would provide the user with rapid menu navigation including familiar slide transitions and header navigation buttons.

Functions would work off of standard hyperlinks and load and postback in their usual fashion. Though any specific mobile web function development should consider leveraging the layer tools in these micro-frameworks. Other mobile web function best practices would include avoiding the IG Grid in lieu of lighter weight options, minimizing the information displayed in any given layer to 5-7 items and providing multiple choice data entry in place of fill in the blank wherever possible.

Sizing the formatting table to 480 x 320 can help give a design time feel for mobile screen territory at standard magnification. HTML meta tags like <meta name="viewport" content="width=device-width; initial-scale=1.0;" /> can be used to control the magnification level of the web function when initially displayed. Since these micro frameworks tend to use CSS hiding techniques they interfere with the design time WSYIWYG in Visual Studio. You can temporarily comment out the stylesheet link in the aspx file to get a better designer experience.

2 bits 4 bits 64 bits a dollar

2010-12-17T15:30:00.008-06:00

The good news: "Mr Newby your new 64 bit Windows-7 8 gig package is ready for you."

The bad news: "Program Files or Program Files (x86)" and "How about that WOW6432Node Eh!"

Sooooooo, I've been installing and uninstalling and tweaking vbproj files and futsing with Visual Build scripts and messing about with InstallShield 2010 scripts and repeating, ad naseum.

But if you are a developer loading up Manage 2000 7.3 sp2 web tools on 64 bit Windows 7 box and you should run into issues, be thankful, it could be much much worse. The sp2 installs are now much more solid.

The most likely annoyance will be dataset references pointing into "Program Files" that can't be resolved because the dataset libraries are now in "Program Files (x86)". You can, of course, simply delete them and then re-add them from the correct location on your box.

Or you can copy the typed library en-masse from Program Files (x86) to Program Files. You just need to remember to copy over dlls anytime you regenerate them through the dataset utility.

Another option is to use the Path Conversion Utility to do a mass change on all the vbproj files in a Manage 2000 web site. This makes sense if all of your production and development web servers are 64bit.

I have also added a PreBuild.cmd script at the Manage2000.vbproj level that you can add under advanced compile options "..\..\..\PreBuild.cmd" for a more surgical approach. As you build projects it will convert the references from hardcoded to "$(ProgramFiles)" which will load and build in either 64 or 32 bit environment. This will prompt you to reload the project during the build if it finds references that must be changed. Otherwise it will let the build continue normally.

Manage 2000 7.4 Web - The Beginnings

2010-11-06T12:20:00.004-05:00

Manage 2000 7.3 field release is well underway and I have finally got some of the bug reports I have been begging for since Beta. Yes, be careful what you wish for. But each one is a treasure that will make 7.3 sp2 a better more solid product when it launches in Q1 of 2011.

Perspectives 2010 is done and now I can turn my attentions to some serious development work for Manage 2000 7.4. My first major task is to build a foundation for web update functions that will be as nice for the keyboard oriented users as PWS functions and that will be as quick to build for the developer.

There have been 4 or 5 update web functions in Manage 2000 since release 7.1 and the BTO framework has always supported update business object processes. But is is not an easy task to build an update web function and the user experience falters particularly for keyboard oriented folks in scrolled set scenarios.

It is remarkable how effective one level of de-normalization in the user interface can be. When you look around at the thousands of Manage 2000 PWS functions almost all of the screens are a collection of single valued prompts with a few scrolled sets. The application developer can express the modeling of complex business processes quite efficiently with this one level de-normalization, taking the user through multiple screens/pages traversing deeper business processing levels. And I wonder if this does not reflect a characteristic of human perception to be interested in a set of data and its immediate context, but no further.

Using grids to implement scrolled sets is like converting an all-terrain vehicle into a riding lawn mower; sure it can be done, but is it the most practical approach? The programming model is too complex and the performance too poor. A much leaner model that only does what is required for scrolled set entry and does not try to be a generalized do everything-2-dimensional container is needed.

So here I am re-casting the SCROLL.MAINT logic Doug wrote 20 years ago into an HTML/JavaScript mold. Am I going backwards, or am I bringing those things that worked and added value into the Dot World?

REST Web Services from UniBasic

2010-09-21T17:39:00.003-05:00

In the midst of working up some labs for Perspectives I started thinking about REST web service access from UniBasic. The lab I happened to be working-up is on SOAP based RPC web service usage, for which we have a number of working examples and implemented projects.

But in creating services for Manage 2000 internal consumption I have all but abandoned SOAP RPC in favor of the far more elegant JSON REST model. I am usually working in ASP.NET and IE DOM client land, thankfully with the prototype.js library. So the question of the day was what would REST JSON access look like from UniBasic and what are the central issues in using it?

Well in addition to all the SOAPRequest support added with the UniBasic Extensions are a couple of simple little commands for retrieving the content from a URL. Now URLs often return HTML intended for human consumption and are not very easy to parse. The JSON REST model however returns very nice orderly string serializations.

With something as simple as:

CREATE.REQUEST.RTN.CODE = createRequest(URL:"?":QS,HTTP.METHOD,HTTP.REQUEST.HANDLE)

SUBMIT.REQUEST.RTN.CODE = submitRequest(HTTP.REQUEST.HANDLE,'','',HTTP.RESPONSE.HEADERS,HTTP.RESPONSE.DATA,HTTP.RESPONSE.STATUS)

you can get orderly responses like:

HTTP.RESPONSE.DATA = {'oValItem':{'FileName':'CM', 'TableNbr':'', 'ItemId':'1024

', 'NewItemId':'1024', 'Valid':'True', 'Display':'Sears Systems, Incorporated',

'ErrorFlag':'False', 'ErrorMsg':''}}

UniData does not yet include a JSON DOM to match the XML DOM of the UniBasic Extensions, but the parsing difficulties of JSON serializations are relatively minor. And if you need to directly access JSON REST services in the middle of UniBasic code this seems like nice direct approach.

The real stumbling blocks aren't coding difficulties, but security of your application server if you open up the HTTP or HTTPS ports for UniBasic to "see" services on the Internet. One answer to this is to go through a proxy server. This also points out one of the benefits of the architecture of Manage 2000 with its ASP.NET arm which may be used in a similar manner to delegate interaction with the messy world away from your closely guarded business database into a DMZ area.

Dynamic Dropdowns and TM JSON arrays

2010-09-02T14:53:00.020-05:00

Whether you call it RIA or Web 2.0 or AJAX enabled, there is an evolutionary process taking place on the web these days with UIs morphing from BLOCK-TERM like full page postbacks to much more granular dynamic changes in the page as the user interacts with it. And you can certainly see the effects of this progression in Manage 2000 release 7.3.

A developer friend asked if I preferred coding in VB in the code-behind ("code-beside" in the new parlance) or on the client using javascript and such. This is one of those questions that makes my brain churn for awhile.

The central conclusion I finally came to was that if it makes the UI more convenient for the user, that I dynamically change control configurations (like reloading drop down options based on previous answers they've selected) as they progress through a page then I prefer taking manual control on the client using javascript. I still use code-behind and aspx templates to push the HTML out in the first place, but then shift to javascript-AJAX-JSON-DHTML to make the user interface reactive and dynamic so that it responds more intelligently to the conversation that the user is having with it without having to pause and reprocess major Page construction code.

So how does one go about dynamically loading an HTML SELECT with options from a Manage 2000 TM table?

I have added a new service called GetTMTable in /mt/JSONServices for just this purpose, using much of the same code as my last post:

Private Function GetTMTableAsJSONArray(ByVal context As HttpContext) As System.Text.StringBuilder

Dim TableNbr As String = context.Request.QueryString("TableNbr")

Dim result As New System.Text.StringBuilder

Dim arTableEntries As New System.Collections.Generic.List(Of Array)

Dim ds As New ROISystems.Components.roiDataSet

Dim TableMaster As New ROISystems.WebControls.roiTableMaster

ds = TableMaster.GetTable(TableNbr)

For Each entry As DataRow In ds.Tables("VALIDATION_Validation_Info").Rows

Dim row() As String = {entry.Item("Code"), entry.Item("Desc")}

arTableEntries.Add(row)

Dim JSONSerializer As New System.Web.Script.Serialization.JavaScriptSerializer

result.Append(JSONSerializer.Serialize(arTableEntries))

Return result

End Function

Here is the js portion of my testcode.

function LoadTable() {

var Site = document.location.pathname.Field('/', 2, 1);

var svcUrl = document.location.protocol

+ '//' + document.location.host

+ '/' + Site + '/MT/JSONServices/GetTMTable.ashx';

var TableNbr = $F('TableNbr');

var qs = 'TableNbr=' + TableNbr + '&Cid=' + $F('hedtcid');

new Ajax.Request(svcUrl + '?' + qs, {

method: 'get', asynchronous: false,

onSuccess: function(transport) {

var arTableEntries = transport.responseJSON;

// clear and reload the dropdown with the new table

$('ddlTMTable').options.length = 0

$A(arTableEntries.each(function(item) {

var opt = document.createElement('option');

opt.text = item[1];

opt.value = item[0];

$('ddlTMTable').options.add(opt);

}))

}

});

}

The result is blindingly fast reloads of the dropdown list from various tables.

When you do finally postback you will run into some MS security checking unless you disable event checking in the page declaration in the aspx file, or in a web config setting:

@ Page EnableEventValidation="false"

pages enableEventValidation="false"

You may also run into occasional confusion during postback on the part of webcontrols code trying to figure out why what is coming back doesn't match what was sent out. To avoid this confusion you can either just use plain ol HTML controls or check the Request.Form("lbID") array directly if it gets to be a problem.

Unfortunately I had to change the roiTableMaster control to remove a dependency on roiPage so that it would work out of JSONServices. This makes it difficult to patch, but it is all better for 7.3 sp2.

In the mean time you could, of course, implement a version of /mt/JSONServices that descends from roiPage rather than IhttpHandler, it just would have all the application overhead that roiPage carries around.

JSON Conversions

2010-07-21T17:46:00.002-05:00

So, I am integrating a provided web page into a Manage 2000 site and I need to supply this external page with a JSON array of data on the querystring based on the contents of a Manage 2000 TM Table.

How to get a JSON serialization out to the client world?

There is a very nice little namespace that I have not previously run across, System.Web.Script.Serialization. And in it you will find a JavaScriptSerializer class (read JSON serializer!).

With the JavaScriptSerializer you can convert a .Net Hash to or from a JSON object, or a .Net System.Array to or from a JSON array, or a bunch of other mappings including your own.

In my case I want to end up with a JSON array of elements with each element comprised of an array of code description pairs.

Private Function GetTMTableAsJSONArray(ByVal TableNbr As String) As System.Text.StringBuilder

Dim result As New System.Text.StringBuilder

Dim TM As New System.Collections.Generic.List(Of Array)

Dim ds As New ROISystems.Components.roiDataSet

ds = TableMaster.GetTable(TableNbr)

For Each entry As DataRow In ds.Tables("VALIDATION_Validation_Info").Rows

Dim row() As String = {"", ""}

row(0) = entry.Item("Code")

row(1) = entry.Item("Desc")

TM.Add(row)

Dim JSONSerializer As New System.Web.Script.Serialization.JavaScriptSerializer

result.Append(JSONSerializer.Serialize(TM))

Return result

End Function

Yes, the JavaScriptSerializer is my new favorite toy for transforming data during client side AJAX activity.

Hyper Activity

2010-07-09T11:45:00.004-05:00

A recent treasure from our 1st live Manage 2000 7.3 site led me back to researching performance issues in the Pegged Detail page of ItemActivity. This has been a long standing issue in the field for certain customers on certain parts under certain circumstances.

Previous optimizations have included converting dynamic arrays to dimensioned arrays when handling the TD_ITEM_PEG_ACT_RESULT file items. But even with attributes stored in separate dimensioned elements the immense number of values that may be generated in the real world overwhelm the UniData box and then moving the gigantic business object to the web server overwhelms that box. The resulting user experience "just sucks".

The real detail work of analyzing pegged detail is done in SUB.BUILD.ITEM.ACT.PEGGED, and entails building a number of attributes for each detail and sorting by date and by a peculiar transaction type order. And there is no good way of separating the selection and sorting of keys from generation of detail data as described in the PAGED.BTO document because the whole point is to keep a running total of availability and a number of calculated and summarized values.

To meet these requirements and scale to many thousands of lines of detail I created a process work file keyed by date and by sequence number and wrote simple flat records for each detail. Then SSELECT the work file and update the small simple records with the running total fields. This replaces a LOCATE and INSERT loop that hockey sticks as the the value count exceeds a thousand. And finally write the results in pages to the WEB_COOKIE_DATA file where each page record only contains, say 25 (users current items per page preference) values for each attribute.

The business object returns only the 1st page of pegged detail and the cookie where the rest of the pages may be found. The web page may then use another business object to read any page of the result the user wishes to view.

Where the business object is handling 3000-4000 details the whole-view multi-valued set approach was taking 6+ seconds on a modern Itanium UNIX box. The work file approach reduced this to less than 1/2 second. And testing shows a performance curve up to 20,000 details running at about 7,000 details per second on our development box.

On the web side the performance improvement is even more dramatic as the dataset and grid processing on large local datasets just overwhelms the web server processor. Eliminating the large business object result, and asking the web server to only create objects representing a single page of the pegged detail, results in near instantaneous page changes even with the trip back to the application server to pick up the page data.

Conventional wisdom says memory is fast, disk is slow. But in this particular scenario it is much more efficient to create a work file, populate it, SSELECT it and work with small flat dynamic arrays than to follow the standard path and attempt in memory sorting of large deep dynamic arrays.

Sub Valued Level Prompting Details

2010-06-03T17:41:00.013-05:00

How do you fixup the screen and do cross referencing and other validations when you use SUB.VALUE.PROMPTING on a SUB.MT500 screen?

Here is an example where we want to prompt for multiple file names and within each file for multiple item ids.

Instead of calling SUB.VALUE.PROMPTING directly from the SCREEN, call your subroutine which in turn will call SUB.VALUE.PROMPTING.

Remember to add right justified fields using the PWS screen in SCREEN.BUILD if you want the count of sub-valued items to line up nicely.

You can add logic to execute only at the sub-valued level by checking X_Data_2 for the FROM.SCROLL.MAINT flag.

2200* Before prompt logic for Item_Attachments

IF INDEX(Prompt.X_Data_2, 'FROM.SCROLL.MAINT', 1) > 0 THEN

* Handle inner event from SUB.VALUE.PROMPTING execution of SCROLL.MAINT

* Reset SIP.VAL.FILE to enable cross referencing

FILE.VALUE = FIELD(Prompt.Display_Text_2, ",", 2)

FILE.LIST = MAIL.FILE.File_Attachments

CURRENT.FILE = FILE.LIST<1,FILE.VALUE>

CALL GET.DB.FILE(SIP.VAL.FILE, CURRENT.FILE)

ERROR = 0

RETURN

END

* Handle MAILBOX.ATT prompt event

GOSUB 2210;* Fixup Prompt Label with SUB.VALUE level display text

* Setup XREF stuff

Prompt.Conversions_Edits = '0X':@SVM:Prompt.Conversions_Edits

* remove compiled edits to force recompile

Prompt.Conversions_Edits = FIELD(Prompt.Conversions_Edits,roiDataMark4,1)

CALL GET.DB.FILE(SIP.VAL.FILE, CURRENT.FILE)

CALL SUB.VALUE.PROMPTING(ANSWER,SUB.DATA,P.NBR,PMT,SAVE.FN,VALUE)

END

RETURN

If you want to fix up details like the screen labels and prompt text while at the sub-valued level you can do this sort thing:

2210* Display SubValue Level Label Text

SET.NBR = Prompt.Scroll_Field_Type[2,2]

LOCATE SET.NBR IN SCROLL.DATA<9,1> SETTING PRIMARY.IDX ELSE RETURN

PRIMARY.PMT.NBR = SCROLL.DATA<1,PRIMARY.IDX>

PRIMARY.PMT = PID(PRIMARY.PMT.NBR)

STARTING.ROW = PRIMARY.PMT<1,7>

HEAD.ROW = STARTING.ROW-1

DISP.MASK = "L#":Prompt.Display_Length

ID.LABEL = XLATE("DICT ":CURRENT.FILE, "F0", 61, "X")

IF ID.LABEL = "" THEN ID.LABEL = "Item Id"

LABEL.TEXT = FMT(P.NBR,"2\0R"):".":VALUE:' ':ID.LABEL

Prompt.Text = "Enter ":ID.LABEL

REDIS.MISC<10> = L(HEAD.ROW):C(PMT<1,6>):LABEL.TEXT DISP.MASK

PRINT REDIS.MISC<10>:

RETURN

For Validation after prompting you can check the X_DATA_2 flag again and if you are at the multi-valued level simply request a repaint with ERROR=1000, but at the sub-valued level actually carry out input validations programmatically. Remember that your sub-valued level validation logic is being called from SCROLL.MAINT so do not use ERROR codes like 200, 1000 as you would for SUB.MT500, simply 0 or 1.

3200* After prompt logic for Item_Attachments

IF INDEX(Prompt.X_Data_2, 'FROM.SCROLL.MAINT', 1) = 0 THEN

* Remove SV Label Text

REDIS.MISC<10> = ''

ERROR = 1000

END ELSE

IF NOT(SIPDATA) THEN RETURN

FILE.VALUE = FIELD(Prompt.Display_Text_2, ",", 2)

FILE.LIST = MAIL.FILE.File_Attachments

CURRENT.FILE = FILE.LIST<1,FILE.VALUE>

REC = XLATE(CURRENT.FILE, ANSWER, -1, 'X')

IF REC = '' THEN

* Message 502: %1 item %2 not on file

CALL SCREEN.MSG(GetMessageText(502,CURRENT.FILE:@VM:ANSWER,0):";H;#M446065")

ERROR = 1

END

RETURN

7.3 sp1 GA Cutoff Week

2010-04-26T18:22:00.004-05:00

Well midnight Thursday is the end of the line for 7.3 sp1 development. I've been cleaning and testing and sweeping up crumbs. My latest clean-up binge has been the DEMO.DATA. The lack of examples of web feeds has been bothering me for the last couple of years, so I bit the bullet and started creating a series of example web feeds for customers, and sales reps, and executives. It's not the end-all and be-all of demo material, but at least it will be there in the SSP account. And it has brought out a number crumbs to clean up :)

I've got one or two more bugs (legitimately called treasures if I can fix them prior to them getting to the field) to clean up before the Thursday cutoff. But I am feeling really good about the Manage-2000 7.3 release. It just has a ton of good stuff.

The Wonderful World of Wizards

2010-03-17T11:35:00.003-05:00

It has been an exhilarating and somewhat exhausting spring here in Minneapolis; from 2+ feet of snow pack to clear yards and 60 degree sunshine in 2-3 weeks. Getting beta's underway has not been fast enough or clean enough for my impatient expectations. But that's why you have betas to find the stumbling blocks. While waiting to enhance as-yet unidentified pre-enhancement conditions, I have been working on a pet project to create web function wizards with more specific generation capabilities.

My first re-visitation to IWizard has resulted in a modest little wizard that will help you generate a HyperQuery web function. The HyperQuery control allows configuration of a REPORT.BUILD like query based web function.

The second undertaking turned out to be a lot more interesting and a lot more work. The BTO Inquiry Wizard allows you to select a business object, select from its available fields and generate a working inquiry with all the data access components and controls configured, and with a FormView containing single valued fields labels and textboxes, and GridView controls for each set.

The great part about wizards is, of course, that you can take the results and enhance the heck out of them. They provide RAD starts to developing your own web functions while still leaving you in total control.

Twas The Night Before Cutoff

2009-12-20T23:40:00.002-06:00

Twas The Night Before Cutoff

Twas the night before cutoff, when all through the house,

Not a programmer was keying, nor clicking their mouse.
The updates all filed into StarTeam with care,
In hopes that Seven_Three soon would be there.

Customers all nestled, snug in releases,
While palmtops and I-Phones sat dark in valises.
And Jimmy in his whites, and I in my cap,
Had just settled our brains for a long winter’s nap.

When out on the Net there arose such a clatter,
I sprang from my twitter to see what was the matter.
Away from my Windows I crept like a gnome,
Searched through my desktop and opened up Chrome.

The Graphic in the heading of the new-painted page
Gave mirth to results there listed by age.
When, what should appear down the page not too far,
But a Manage 2000 and 5 rating gold stars.

With data entry screens, so lively and quick,
I knew without thinking it started on PICK.
On UniData it thrives with GFE-free frames,
And whistles, and whirrs, and remembers their names

"Now Namer! now Schoolboy! now Farmboy and Widget!
On Motor Mouth! On Cheese Head! on Professor and Gidget!
To EDX, to SCREEN.BUILD, to BX REBUILD ALL

Now dot away! Dot away! Dot away all!"

The founder with his satchel all stuffed full of papers.

The performer and painter both cooking up capers.

The young black bird that had grown up so tall,

Leading us onward from the end of the hall.

As dry leaves that before the wild hurricane fly,
When they meet with an obstacle, mount to the sky.

So with hope of happy havens away they all flew,
Leaving a product full of toys, and Last Keys support too.

And then from the Palace, gave we measured lecture,
With summary and bullet of each treasured feature.
As I drew in my head, with my neck like a crane,
Down the cat-5 a new release came.

It spoke not a word, but went straight to its work,
And filled all the data, then re-painted with perk.
And laying a finger on top of my mouse,
I attached on my portal a jpg'ed house!

And then on a lark in a moment of need,

I dialed in from home to setup a Feed.

It summarized sales figures and displayed on my mobile,

It remembered my context and let me go global.

Saved out on disk, Install Shield's new folder,
Languishing there whilest the weather grows colder.
I heard it exclaim, ‘ere it shrank out of sight,
"Happy upgrade to all, and to all a good-night!"

- with inspiration from the Sniggletter

- and with apologies to Clement Clark Moore and Henry Livingston

Whats It All About ... Alpha

2009-12-13T17:58:00.002-06:00

The alpha test cycle of Manage 2000 release 7.3 is complete. Time to send it through the car wash and prepare for delivery to our beta sites. Lane and Alky will have a busy January getting a clean release ready for Tina, Mark, and Mike. I have to bite my development tongue and stop trying to sneak one more feature into the web tools. Time to get busy on the component and control documentation and the web course-ware instead, to catch it up to the VS2008 world.

Can't stop thinking about the impact of all the development work from over the past two years for Manage 2000 sites going to 7.3.

Sprinting To The 7.3 Finish Line

2009-11-27T11:45:00.004-06:00

Funny things happen when you present your work to others. Brain cells fire about what you wish you had done in addition to what you did actually accomplish. I had just finished talking about the web last keys enhancements and was getting ready to talk about web feeds when some severely neglected axons and dendrites conspired to revolt, or in this case maybe just volt, and then it occurred to me...

So, what if you put up the Manage 2000 7.3 site as an externally facing portal. And what if the portals supported attachments. Customers could attach documents to sales orders, or vendors could attach documents to purchase orders and internal users could interact with the attachments from the internal portals, or in fact from PWS functions.

I was not thinking I could sneak this in before Beta, but as of Wed. morning I have been merrily attaching objects via portals on our development box. And more importantly (as Jim often reminds me) it's cute.

Summer's End 2009

2009-10-07T20:13:00.002-05:00

Perspectives session material was due in last Friday. Now I can get back to building new stuff. I still haven't finished the display panel memory. It is a small annoyance, but a general client side context persistence mechanism will come handy over and over.

There also remains some fleshing out of the metadata implementation. In particular being able to set an M2k edit pattern and have a Regex generated and applied to the input would be sweet. I'd also like to get any existing pattern matching or required validators to be automatically tied in...December is rapidly approaching, we'll see what we can sneak in. The performance exception logging and user preference extensions are a must, so I guess I better start on those directly.

I just put in a replacement for the dorky alerts with which I was displaying ?3 and ?5 help. Now we have a nifty m2kShowMessage(hmtlMsg) js function with which it is easy to compose an HTML display and pop it up using an in-line div that won't set off the pop-up blockers.

Now What To Do With All This Cool Stuff

2009-08-22T22:57:00.002-05:00

So we've got prototype.js and .Net 3.5, what does that mean to the users. Well for ESOP users it means a killer shopping cart app. Fast, fast, fast. Constantly saved carts. In screen customer pricing and critical path availability date calculations. Cart navigation using page-up, page-down, line-up, line-down keyboard keys, or of course, mousing. 2-3 click checkout.

SoPortal advance search now sports a faster cleaner data entry screen with instant validation displays.

ProductConfigurator generates CONFIG.CODE based model entry screens with high speed data entry using delimiter and section lengths.

And of course lots better cross browser support for Firefox users.

Manage 2000 Web 2.0

2009-07-16T20:38:00.002-05:00

No, I don't know what it means either. But I do think the web user experience on Manage 2000 7.3 is going to be noticeably and, in many cases, dramatically improved from the 7.1/7.2 technology. It seems to me like the we are passing through the 3rd generation up the web UI S-curve. With release 7.0 we dabbled with asp script based web infrastructure. We've had a good run with Visual Studio 2003 and ASP.NET 1.1 as a basis for Manage 2000 7.1/7.2 releases. And now with release 7.3 we are working on top of ASP.NET 3.5 using VS 2008 with more current infragistics controls and a much more robust client side javascript infrastructure library roiGlobal.js with deeper support from the Prototype.js, which underlies many other clientside toolsets such as Ruby-On-Rails and Scriptoculus.

Every project brings with it opportunities to enrich the roiGlobal.js library and move more time sensitive user interactions to the client-side world of javascript, D-HTML, JSON, and AJAX. Yet even as I explore these new environments and tools I find myself re-creating patterns from the PWS / SUB.MT500 world. There are few things as elegant and powerful as the declaritive UI specificaton for a computer prompting a user which is called the PID in M2k geekspeak.

Following that pattern Manage 2000 7.3 web pages all have the equivalent of PID available. It is defined in roiGlobal.js based on a Prototype.js class called a Hash. It's name in nvcMetaData, and it is to the web function what PID(40) is to the PWS function. That is to say that dynamically altering the metadata item for an HTML textbox effectively controls its behavior. Thus, application behavior can be achieved by setting properties of the metadata instead of having to code up all the necessary javascript.

Puttin On The Ritz

2009-05-24T11:37:00.002-05:00

The Mid-Western User Group meeting was held on Thursday with folks coming in from as far away as Indiana and Illinois. It was, as usual, a family reunion atmosphere with familiar faces and warm greetings. What strikes me about the content, looking back at it, is the amount of information exposure possiblities. MITS 2nd go-round on its report writer looks well done. The NovoRoiSystems real-time SQL data warehouse continues to wow. Now with more in-bound interfacing it is starting to grow into something much more significant than just an on-ramp to MS Reporting Services. I spent some time on the growing ATOM/RSS news feed capabilities.

The most fun, for me, was showing off the 7.3 web UI improvements with Last Keys, Most Recently Used stacks and AutoFill. We broke the seamingly endless barage of technical detail with YouTube clips from the "Puttin On The Ritz" Gene Wilder/Peter Boyle song and dance number in "Young Frankenstein". Don't know that I could sing and dance on the same stage as Gene Wilder, but I feel pretty confident about being able to croon along with the monster!

After a memorial day break I'll be heading back into the 15 portal projects. I am adding a news reader panel that can display a configurable Manage 2000 news feed, and converting them from XSLT generated forms to WebControls so that they can be controlled through the PageViewFilter system. Fun, fun, fun....

Last Keys and Other UI Friendliness

2009-04-04T15:20:00.003-05:00

The last keys project is winding down. I just checked in the latest round of javascript upgrade for the m2kInputData function which includes a Most-Recently-Used stack on the up/down arrows, automatic display of validation name or description, and Auto-Fill from the MRU stack. Yes scope creep is a problem, but they were low hanging fruit once the \LK infrastructure was developed. It would be wasteful not to gather them in while I was harvesting.

There are still a few more i's to dot and t's to cross, but it is starting to feel pretty impressive when you type along on the devweb and get the sort of experience you are only used to from PWS.

Next up will be some refactoring to reduce the startup time from PWS.

Last Keys Part I

2009-03-08T23:36:00.002-05:00

The Last Keys project is well under way. I've just completed the conversion on the UniBasic side that will allow participation from the web side to work. Last Friday I got far enough to run a few timings from an HttpHandler through from the web site and am getting last keys values in less than 1/30 of a second. So performance-wise the current design is proving out well. Lots of work awaits in the roiTextbox and javascript libraries. Switching from heavy Unibasic work back to .NET seems alot like getting ones sea legs. Takes a couple of days before I can code straight, or perhaps at the correct Microsoft pitched angles.

A major part of the speed I am seeing is from tools improvements that Doug and I were able to put into the CallRPCSub routine which shepards all the calls coming in across RedBack. We've been able to shave .1 to .4 seconds off of each RPC call. This has been patched back to 7.1 and 7.2 so 7.1sp7 and 7.2sp4 should show significant speed improvements for all the web functions.

Release 7.3 Project Progress

2009-01-31T13:08:00.003-06:00

Despite broken ankles and bouts of pneumonia Doug and I finally have the Manage 2000 web functions building under VS2008. There remains a little tweaking to do on the installations routines. But at last I feel like I can concentrate on new feature development.

I have started down the development list and finished my first significant web tools enhancement for 7.3, the integration of ECA's and the news feed system. ECA's provide rich html scripting from all sorts of system events. News feeds provide standard pluggable integration to Sharepoint and other web platforms. Putting the two together really extends the news source capabilities to 'broadcast' all sorts of automated news articles as the ERP systems churns through its machinations.

Next up is Last Key integration between PWS sessions and web functions. This will, in all likely hood, be the largest project I undertake for the 7.3 release (not counting the VS2008 ASP.NET 3.5 infrastructure upgrade).

I am still in the early stages of design, but have identified a whole raft of issues that were not obvious to me during my initial rough cut do-ability considerations. I didn't realize how much of the fun part of working on Manage 2000 are these design conundrums that must be puzzled and teased out.

Visual Studio 2008 and Manage 2000 Web Functions

2008-12-12T14:27:00.004-06:00

Mark your calendar 13:58 on December 12, 2008 the development staff completed the last of the 295 ASP.NET web projects, thus heaving the Manage 2000 7.3 web footprint on top Microsoft's not-so-backwardly-compatible Visual Studio 2008 designer.

This is an important achievement in terms of product life expectancy as it puts the Manage 2000 web presence on supported Microsoft technology for at least the next 5 years.

Hopefully, next time they will be a little kinder and gentler with backward compatibility.

This is not the end of development for the 7.3 release. It is not even the beginning of the end, but merely the end of the beginning,to paraphrase Carnahan paraphrasing Churchill.

Next up is build and install capability so that as developers add and enhance application functionality we can easily re-install development sites and do integration testing.

Then the real fun begins putting to good use all of the fantastic enhancements in ASP.NET 3.5 and Infragistics 2008 to make Manage 2000 7.3 web functions sizzle.

7.2 Release and Looking Ahead

2007-02-12T01:11:00.000-06:00

Entry for February 11, 2007

After 10 days of negatives temps, some days with -5 for a high, I am ready to be out of the deep freeze. Past -10 my car sleeps with a trouble light under the hood to make sure I can get the kids to school in the morning. Maybe time to add that block heater.

The 7.2 release is currently in Beta. Lots of positive feedback, as well as, bug reports and clean-up work.

We are currently conducting training presentations to helpline, custom code and consultants. Last week I covered PageViewFilters and other tools enhancements, as well as, the new web ProductConfigurator interperter for implementing CTO on the web.

I continue to scout out the direction ahead with Visual Studio 2005 and ASP.NET 2.0. The way looks rough but passable at the moment, though where we all end up is sure to be filled with complaints. There are some tools I can write to smooth the way, but there are significant short-comings in the VS2005 IDE. The VS team seems to have fixated on codeless access to SQL and forsaken all other paths. Everything is focused on stateless, first-normal data updates between flat UI components and the SQL database, or some other object which must be organized along the same CRUD lines in a first normal world. They do not appear to have made any accomodation for web base applications with rich hierarchical complex UI's. Apparently we are supposed to use winforms unless we are implementing an Amazon.com web site. There are web sites and then there are web applications. Microsoft appears to be pressuring the web application camp back to winforms.

In particular databinding UI from hierarchical datasets to webcontrols is just plain gone. They have drastically different models for winform data access as compared to web forms. They are pushing ObjectDataSource and SqlDataSource as codeless access to databases and great productivity enhancements. But these depend on new TableAdapters within the dataset to orchestrate flat table accesses back and forth to the DB. They are tightly coupling the UI to the DB.

For thoses of us with ACID processes based on hierarchical datasets there is no room to fit in. The idea that first normal database requirements are going to start driving UI design is just plain scary. It may be ultra productive for the person creating it, but it's going to be butt ugly for the poor soul who has to actually use such software.

On another front I am watching Orcas with amusement. They are so hyped about LINQ and the ability to hook up SQL query statements to gridview. Manage 2000 has been delivering web query capability for over 5 years which include embedded sub-tables and hyperlinking. Our queries can even be defined from a report generator UI. I predict that when LINQ gets to field everyone will discover there is still a lot of problems because they will often want a three dimensional query result and you can't get that from a first-normal database without a lot of effort.

The reign of quality fights for a hierarchical object oriented UI. The reign of quantity fights for simple flat table models. Who will win?

ERPBusinessObjectService - M2k SOA

2006-10-10T01:10:00.000-05:00

Entry for October 09, 2006

Manage 2000 7.2 sp0 is "in the can". Most of the preparations for Perspectives have been finished. And now the development team is settling into a pleasant lull after the long hard summer. There remain the perrenial small projects to occupy us until the beta sites start feeding us the work which will make 7.2 "sea-worthy".

I am happy with amount of "cool stuff" which made it into 7.2. And yet, in each major project, I can see another level to climb up to.

The ERPBusinessObjectService, in particular, has some very important new features. Unfortunately there is no session planned for it as Perspectives. But maybe I can sneak in some attention to it.

There is the beginnings of legitmate interest in web services among clients, and 7.2 ERPBusinessObjectService provides new useful methods:

* ValidateRecordKey - for validating parts and customers without having to export and refresh Manage 2000 file contents to SQL tables
* CallUdtSub - for running UniBasic subroutines across SOAP. A Unibasic programmer can write a routine and a web developer can instantly make use of it.
* UniQuerySelect, GetKeysFromCookie, and GetItemsAsXML provide the foundation for running UniQuery processes returning XML content.

Product Configurator Challenge

2006-04-19T01:09:00.000-05:00

Entry for April 18, 2006

The long nights of winter have passed. The garden is uncovered. Most of the spring pruning is complete and life is bursting out to greet the strong sun shine.

FRx deployment has been passed along to Lane. The PageView Filter system has been completed. The web Product Configurator is undergoing testing and revision. Some version of rule support will definitely make the 7.2 cut. Trying to run Unibasic prompt after subs in the middle of a web page will not make the cut. Although it does make my head hurt.

"The World Is Flat" continues to resonate with increasing numbers of 7.1 Manage 2000 sites. We have work to do.

FRx Interuptions

2006-02-10T01:08:00.000-06:00

Wimpy Winter Weather here in Minneapolis this year. The side roads are finally died white after todays not so rush hour dusting. Like one who grew up with the white trunks of a birch forest there is an unconscious expectation of color reversal which surprises me when it goes missing.

Round II of PageViewFilters and completion of the CTO Interpreter have languished while I help with field support for the FRx interface to the GltInquiry web function.

All of my relections lately are colored by Thomas Friedman's "The World Is Flat". I wonder about the shift of emphasis from internal development in Manage 2000 to building the myriad of interfaces onto complimentary products available with 7.1. I wonder how the 7.1 web function capabiliy will help customers cope with the flattening world. How fast is the game changing. How much time do business have to adjust, deploy, invent.

Through the Looking Glass

2005-12-07T01:05:00.000-06:00

Well I am getting ready for move number 3 since EPICOR bought out ROI Systems. Friday I pack up my cubicle for relocation to the 11th floor. Somehow the square footage of cubible allocated per programmer continues to dwindle. I am hoping the accountants are not shooting for equilibrium based on square foot costs in Monterey. On the upside the hallways are very wide and luxurious!

As I reflect on email queries from client web programmers obviously schooled in SQL and not so familiar with the Unidata world or the Manage 2000 toolset, it is clear to me that the REPORT.BUILD interpreter and the roiHyperQuery control offer extremely cheap efficient options for exposing ERP data out to the world. Only it is difficult to help them 'see' it. The expectation that knowing sqlCommand is enough is too stultifying. Is it worth learning another layer beyond Microsoft technology? When that layer provides CrossRef and Function Security and F1 help and edit patterns and defaults maintainable in dictionaries on the application server, and dictionary driven queries, and interactive UI screens based on REPORT.BUILD prompt definitions, the answer to me is clearly yes. But you have to expect to spend some time coming up to speed. There is a lot of tooling knowledge to learn.