Creating
a Client Interface for a MANASYS Jazz Web Service
See Road Map for proposed future development
Contents
Creating a Client Interface
for a MANASYS Jazz Web Service.
Revision:
Creating a JSON Web Service
Step
1. Create an Interface Project
Step
2 (Optional). Create Projects for Test Objects
Step
3. Configure Jazz – Client Tab
Step
4. Configure Jazz – Workbench Tab
Step
1. Locating JSON and Creating the
Message Descriptions.
Step2. Creating the Client Interface
Server-side
and Client-Side Validation
When
do you Need to Re-create a Client Interface?
To
Re-create a Client Interface
Getting
Started – Locate or Create a Suitable Project
Client
Projects with Multiple Forms
Introduction:
Test Data for JSPG3
Creating
and testing JSPG3Client
Messages
– COBOL, JSON, C#, and Binding.
Understanding
the Client Interface
Introduction
In minutes MANASYS Jazz can generate a CICS Web Service that can perform enquiry and/or update from one or several VSAM files or DB2 database tables, generating hundreds of lines of COBOL logic and also the necessary supporting objects (WSDL or JSON, and the binding objects that convert between JSON or WSDL and COBOL). The COBOL logic will validate incoming data and implement the rules of the web service such as “Update must follow an enquiry”.
Both REST (JSON) and SOAP (WSDL) services can immediately be tested with utilities like PostMan and ReadyAPI, but even though a ReadyAPI test can be created in minutes it is far from easy to develop a client-side program to interact with a CICS Web Service, especially if you want client-side validation to avoid unnecessary web service requests. However MANASYS Jazz can now generate an interface object for JSON web services that makes client development very easy. Click here to see a short video introducing this process. The interface exposes properties and methods encapsulating the rules of the service: for example Employee.Sex must be M or F, Employee.Empno must be numeric, Update must follow an Enquiry and must return the CheckSum value from the Enquiry, and so on. Clients need only refer to the properties and methods provided by the interface object to obey the rules. Agile development is now easy: should the web service change we only need to re-generate the interface object to reflect new rules and data. The Client Program (which you write) will need changes only if it needs to reflect new functions and data provided by the new version of the service.
In the diagram above, Jazz will have generated the service MyJSv-JSPG2 as a COBOL program on the “mainframe”. The right hand part of the diagram represents either a real zOS mainframe, or a Micro Focus Enterprise software mainframe, containing COBOL generated by MANASYS Jazz that we have compiled to access data in response to input messages, and respond with output messages.
The middle part of the diagram represents the interface JSPG2Client, a C# object in your MyJSv interfaces project. Why C#? By targeting C# and .NET Core the interface can be used not only in Windows, but also with Linux, Android, IOS, and perhaps other operating systems. This will become part of the client program (probably most of it), so it is separate from the “mainframe” on the right.
You will write the actual client-side logic in the language of your choice – VB.NET, C#, Java, … for whatever client environment you are using (Windows form, Web page, mobile app…). This will be a separate Visual Studio project: I’ve called mine “MyJSvClientTests”. You’ll learn how to create interfaces and tests below.
As later programs are generated their interfaces are added into the interface project for the service: -
You will have already created the COBOL Web service (see Revision: Creating a JSON Web Service below as an example). This Users’ Guide chapter shows you how to create these client-side interfaces (middle section) and the actual client program (left section).
Note: this chapter uses various programs within service MyJSv for its examples. Programs have names starting with “JS”, so when you see “JSPG2” or “MyJSv” written, including as parts of longer words, mentally substitute your own names. For a full list of the programs that might have been used in demonstrations, see Programs used as Examples.
Prerequisites
Web Service Clients like Interface JSPG2Client in the diagram above are delivered as C# objects. You need to have Visual Studio 2019 16.4 or later, and .Net Core 3.1 SDK or later.
You need to be using MANASYS Jazz version 3.16.1.239 or later.
This facility is only available for JSON (=REST) web services. It is not available for WSDL (=SOAP) services. REST now seems dominant, and so equivalent SOAP facilities are unlikely to be developed unless requested and funded.
Revision: Creating a JSON Web
Service
Jazz web service programs like JSPG1 and JSPG2 can be quickly generated from a Jazz-format definition data definition. In this example we’re going to create program JSPG2A to update the Employee table from IBM’s DB2 Sample database. This definition was created from the New/Data/Import from SQL (select table EMPLOYEE) and then editing the definition to add extra information such as validity rules. Here is the definition Employee.jzc, with highlighting to show my editing changes: -
*#
Last Updated by JAZZUSR at 17/07/2023 11:33:11 AM
*#
Created from Table:EMPLOYEE,
Schema:Robertbw10, Database:sample by JAZZUSR at
6/05/2023 12:05:36 PM
COPY Department;
DEFINE EMPLOYEE SQL DATA(
EMPNO CHAR(6) PIC '999999' REQUIRED KEY,
FIRSTNME VARCHAR(12) REQUIRED,
MIDINIT CHAR(1),
LASTNAME VARCHAR(15) REQUIRED,
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
PHONENO CHAR(4) PIC '9999',
HIREDATE DATE,
JOB CHAR(8),
EDLEVEL SMALLINT REQUIRED,
SEX CHAR(1) CAPS CODES(M:Male,F:Female),
BIRTHDATE DATE,
SALARY MONEY(9,2) MIN 0,
BONUS MONEY(9,2) MIN 0,
COMM MONEY(9,2) MIN 0,
CURRENCY CHAR(3),
DEPTMGR CHAR(1),
STARTTIME TIME);
Editing changes were: -
· To SQL EMPNO and PHONENO were simply CHAR fields, but they were supposed to be character-format positive integers. SQL doesn’t support a PICTURE data type, but Jazz allows PIC to be given as a property. Now any attempt to assign a value other than 000000 to 999999 to EMPNO will be detected and reported by ACCEPT.
·
WORKDEPT is a foreign key.
EXISTS ensures that non-null values
must be current values of the primary key of DEPARTMENT. So that the reference DEPARTMENT.DEPTNO is recognized correctly COPY Department; is added before DEFINE
Employee …
By also adding CAPS MANASYS ensures that values received
as (for example) “d11” will be converted to “D11”. We strongly recommend that any KEY, DKEY, or UKEY field use CAPS to avoid
errors and ambiguity.
· SEX can have any value as far as SQL is concerned, but the actual data rules are that it must be M meaning Male, or F meaning Female. Adding CODES(M:Male, F:Female) specifies this. As with a key value, CAPS is recommended.
· Import from SQL rendered SALARY, BONUS, and COMM as DECIMAL. Changing DECIMAL to MONEY will display them with $, and MIN 0 ensures that they can’t be -ve.
· I added CURRENCY, DEPTMGR and STARTTIME to IBM’s definition of the EMPLOYEE table.
o CURRENCY was added to test that MANASYS Jazz could handle COBOL reserved words as SQL column names
o DEPTMGR was added to test that a typical “COBOL Boolean value” – a CHAR(1) field with possible values ‘Y’ or ‘N’ – would be handled correctly as a C# Boolean field with values True or False.
o STARTTIME was added (later, build #303) to test that TIME data is handled correctly in clients.
With Employee.jzc properly defined, the dialog New/Logic/Web service, with values like this, creates program JSPG2A to update the Employee table: -
This dialog creates a Jazz definition of the request and response messages, and of the logic of the program (in this case a single-table update program with CICS-style pseudo-locking). Here is the message definition for JSPG2A. Here is a copy of program JSPG2A as Jazz, and as COBOL.
A web service request/response is a relatively slow process, in my test environment taking about 3 seconds whatever the size of the web service message, so it makes sense to return as much as possible each time. Employee is defined with a duplicate key (WorkDept), and with my test data there were 14 records with WorkDept = D11, so JSPG2A was generated like JSPG2 except that I set Max >1. If this were a production situation, I’d set max to 14 or greater. For my testing I set Max=6 to test that the generated logic handled scrolling forward and back, automatically getting the next 6 (and the next) as you scroll forward. The takeaway: set Max as large as necessary, but it doesn’t have to be the maximum possible. See the appendix Returning Multiple Records for more information.
The process is completed by compiling the COBOL, and generating the binding objects: the JSON description of the input and output messages, and WSBIND to convert these from and to COBOL. With Jazz configured for zOS this happens automatically as JCL is created and submitted to compile the COBOL and then perform further steps to create the binding objects. With Jazz configured for Micro Focus Enterprise Developer (MFED) there are a series of dialog steps to achieve the same effect. This is covered elsewhere: see here for zOS, and here for MFED
Statistics so far: Employee.jzc is 19 lines of code, 10 of which we edited. From this we generated 58 lines of Jazz message definition (editable, but we didn’t in this case), and 28 lines of Jazz program logic (which again, we didn’t edit). This became 2580 lines of COBOL, and the ZOS or MFED process created 355 lines of JSON and the binding objects to convert between COBOL and JSON. All of this compiles cleanly first time, and we have a running web service that can be tested with utilities such as ReadyAPI.
Now to get back to the real point of this Users’ Guide chapter, which is creating a client interface to make using such web services easy. First we must configure MANASYS Jazz to create Client Interfaces.
Configuration and Set Up
We must first create an empty ASP.NET Core Web Application. Then we will configure Jazz so it knows where to find this, so that it can create and update objects within it.
Step 1. Create an
Interface Project
1. Open Visual Studio, create a new project. =>
2. Select template ASP.NET Core Web Application, click [Next] =>
3.
Name the project MyJSv (or your web service name, see above).
Note the location (e.g. copy it to the clipboard). For me, this was
C:\Users\Robertbw10\source\repos
Check “Place solution and project in the same directory”.
Click [Create] =>
4. Choose a template. I’ve chosen Empty. Click [Create] =>
Visual Studio creates the project and opens on an initial screen. Solution explorer shows
5.
The generated interface is going to include the line
using Newtonsoft.Json;
To make this valid in project MyJSv, click menu Tools > Nuget Package Manager > Manage NuGet Packages for Solution.
Select the Browse Tab. If Newtonsoft.Json is not already shown in this tab, enter Newtonsoft.json and click search
Click this. It appears to the right.
Click [ ] Project and then Install. Click [OK] when asked.
Step 2
(Optional). Create Projects for Test Objects
This
is a planned feature, it is not implemented yet.
As well as the interface itself (the
middle object in the diagram above) it is intended
that Jazz will create template objects that will use the interface objects if
you check the relevant Web or Windows checkbox (the left object in the
diagram). These template objects are
basic Windows or Web programs that invoke the interface to use the web service:
they are unlikely to appear or do exactly what you want, but they will have
some code that you can adapt. Template
objects are usually created into separate projects, with default names MyJSvCS, MyJSvVB, MyJSvJV, etc. C#
objects can be created directly into the interface project.
If you are going to use this feature,
then you need to identify the target projects before Jazz generates objects
into them. If necessary, create new VB
and Java projects with appropriate templates.
Add a reference to the MyJSv project to these
projects.
Step
3. Configure Jazz – Client Tab
Click
[Configure], click the Client tab. Identify the full path to the project file
created above where the MyJSv (or your name) project
has been created. For example,
C:\Users\Robertbw10\source\repos\MyJSv.
If you want template objects check the
relevant checkboxes, and set or locate the relevant project (optional for C#). Close the Configure form.
Step
4. Configure Jazz – Workbench Tab
Interface generation uses a number of
C# templates, with names @xxxx.cs. The
current list is below. They should have
been installed with Jazz, and be in your Jazz Programs folder (for me,
C:\Tutorials\TstSQL\Jazz_Programs).
@BoolValue.cs
@Child.cs
@DateValue.cs
@Delete.cs
@Enquiry.cs
@InList.cs
@IsBool.cs
@IsDate.cs
@IsFloat.cs
@IsInt.cs
@IsNoLongerThan.cs
@IsTime.cs
@JazzClient.cs
@Method.cs
@PChild.cs
@ReadNoScroll.cs
@ReadScroll.cs
@ReadScrollChild.cs
@RequestResponse.cs
@TimeValue.cs
@Update.cs
If necessary, install these
objects from the Jazz workbench with [Configure]/[Initialise
Project] from the Workbench Options tab.
With
the objects selected, click [Open]. This
will copy them to your programs folder, so that they can be copied to the
interface project created in Step 1.
Creating
a Client Interface
To
create an interface, open the web service program for which you want to create
an interface in the Jazz Workbench. If
it is a JSON web service, the button after [Configure] will be enabled and be
labelled [Client]. You will need to have
completed the development of the web service, not just generating
COBOL but also compiling the COBOL and creating the Binding File and JSON
message descriptions. You may have
tested that your service works to at least a rudimentary level with a test
utility like Postman or ReadyAPI.
Click [Process] to create the latest version of your
program, then depending on your test environment: -
·
z/OS: [Process] submits
the job for remote compilation. For a
web service the job includes post-compilation steps to generate the JSON
definitions and WSBind (a program which converts
between COBOL ó JSON Layouts). These are created somewhere on your z/OS
system, so you need to get them back to your local (Windows) environment for
the next step. You don’t
need the WSBind locally, leave this on z/OS., but
copy the JSON layouts back to your Windows environment, into the root folder of
your COBOL project. For example, I’m
using a folder structure C:Tutorials\TSTSQL that
contains subfolders \Jazz Programs etc. For a program named JSPG2 the
post-compilation steps will have created path/JSPG2I.JSON and path/JSPG2O.JSON. Find path from your JCL, and copy
these to objects to your equivalent of C:Tutorials\TSTSQL. Hint: right-click [Process]: you’ll see that the bottom section of this form provides
Windows ó z/OS upload and download.
·
Micro
Focus: [Process]
creates COBOL, and then passes control to the Micro Focus COBOL project. Compile the COBOL, then create the web
service interface and binding objects as described here,
particularly the section headed Prepare
Web Services for Testing. If you are
re-creating a client interface after modifying a program, make sure that you’re
using the most recent version of the binding objects by deleting and recreating
the service interface (.svi) and associated objects (.wsbind, and .json). See When do you Need
to Re-create a Client Interface? for more
information.
Click
[Client] and the Web Service Client Interface dialog appears: -
WebAPI was set with Configure/Client (in Step
3. Configure Jazz), and is the
location of your C# project. Service and
program name come from the PROGRAM statement.
The Service name must be the same as the last level of WebApi, i.e. MyJSv in the example
above.
If
you have already created this interface check [ ] Replace to re-create it. Local JSON will always be checked: the
checkbox is provided to indicate future development, which may provide a browse
dialog allowing you to search for the relevant JSON.
Click [Create Interface].
Jazz will create a C# interface object called xxxxClient.cs,
e.g. JSPG2Client.cs, and message #577 will appear just below the PROGRAM statement: -
PROGRAM JSPG2B
WEBSERVICE MyJSv CONTAINER
DFHWS-DATA DATABASE
sample DB2 JSON;
#577
I JSPG2BClient has been generated in C:\Users\Robertbw10\source\repos\MyJSv
If
errors are detected then messages are reported as Jazz Error messages,
following the Program statement: -
If you
have configured MANASYS Jazz to work with Micro Focus Enterprise Developer, all
the required .json files will already be in your
project folder (in my case C:\tutorials\TSTSQL\.
If
you have configured MANASYS Jazz to work directly with z/OS, the
.wsbind and .json
files are created on the mainframe, and you will need to copy the Input and
Output definitions, xxxxI.json and xxxxO.json, back to your local (Windows) environment. The top level Swagger definition, xxxx.json is created directly into
your project folder when you created the Web Service program, so you won’t need
to copy this. Hint: right-click
[Process], and use the lower part of the [Process] form to download the two .json objects that you need.
Step
1. Locating JSON and Creating the
Message Descriptions.
When [Create Interface] is clicked, Jazz first locates the
JSON descriptions of the web service.
After you’ve turned your Jazz program into
COBOL, compiled this, and created the support objects (“Binding file” or
“WSBIND”), three .json files should have been written
into your project file. For example, my
project file (which I set with [Configure]) is
C:\tutorials\TstSQL. For program JSPG2
C:\tutorials\TstSQL\ contains these three .json
files: -
·
JSPG2.json This is created directly by Jazz when
you generated program JSPG2: it is a Swagger definition that defines the
service and has references to the message formats (schemas) JSPG2I and
JSPG2O. These don’t
exist when it is first created.
·
JSPG2I.json This describes the Input (Request)
message. It is created later, by either
ZOS or Micro Focus. If created by ZOS it
will have originally been created on a mainframe, and should have been copied
back to your project file.
·
JSPG2O.json This describes the Output (Response)
message. Like JSPG2I it is created
later.
From
the Swagger definition Jazz extracts path information
(request type – post, put, etc, and path, e.g.
http://localhost:9003/cics/services/JSPG2), and references to the schemas for
the input and output messages. The input
and output schemas are vital as they describe the format of the messages sent
to and from the web service.
If
these files can’t be located then message #559 will be
produced. To correct the problem, first
check that all the steps after producing COBOL – compile the COBOL, produce
binding file and JSON – have been
completed (e.g. by testing the service with a utility like Postman or ReadyAPI). If you can run such a test then JSON has
been produced, although the JSON may still be only on the mainframe. Locate this JSON manually, and copy it to
your project folder.
If the JSON exists then the message definitions are created:
-
RequestJSPG2.cs Created
from the input message, JSPG2I, this is the actual structure of the request
message.
ResponseJSPG2.cs Created from the output message, JSPG2O, this
is the actual structure of the response message.
If
you were to examine your C# interface project, it would now look like this
except for the client object (JSPG2Client.cs) which will be created in the next
step.
Step
1 has created the Request and Response objects, like the examples below. Next Jazz creates the interface object,
JSPG2Client.
Step2. Creating the Client Interface
An
object like JSPG2Client provides one or more
methods to communicate with the web service.
Program JSPG2 requires at least four methods, Enquiry, Update, Add, and
Delete, corresponding to the possible values of Function, and there are also ReadNext, ReadLast, ReadPrev and ReadFirst methods
because the Enquiry offers a scrolling option if you read records by the
duplicate key, WorkDept. Other clients might include Logon, Logoff,
New Order, Process Order etc.
The
process starts by reading a template, @JazzClient.cs,
into memory, substituting values for @Service (=MyJSv)
and @Program(=JSPG2), and removing markers like @Private after pointers are set
to the preceding lines. The Client
object is then generated based on all the information that is available to
program JSPG2. You can learn more about
it at Understanding the Client Interface.
Server-side
and Client-Side Validation
The
purpose of a client interface like JSPG2Client.cs is to make it much easier for
client programs to interface with the web service, and to provide local
validation so that errors are detected instantly rather than with the delay
inherent in a Request/Response cycle.
However local and remote validation rules may differ:
1. Validation requiring further
I/O, such as an EXISTS property,
is not checked locally. For example, Employee.Workdept is defined
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
To be valid any value entered for WorkDept
must exist as a value of DEPARTMENT.DEPTNO,
the primary key of the DEPARTMENT table.
This is not checked within JSPG2Client.
There would be no point in doing this: it can only be checked by sending
a request to a web service, incurring the response delay that local validation
is supposed to prevent.
2. CHECKR properties are defined in
the record definition to specify Check Routines, which are routines (paragraphs
or subprograms) that check particular fields, for
example a bank account, social security number, etc. The web service knows their names and
interface rules, but not their internal logic, and they may be written in COBOL
or any language that can be called from a COBOL program. A Check Routine might
even require server-side I/O, for example looking up reference tables. Like EXISTS, these are not checked
locally.
Future development:
it should be possible to write your own local routines, for example to check that
a social security number has the correct format, and use these in an interface.
3. Some local validation may
follow different rules because formats are different, or COBOL and C# follow
different rules. Particular
examples:
a.
A
Jazz BOOLEAN field is usually CHAR(1) with ‘Y’ meaning ‘true’
and not ‘Y’ meaning ‘false’. The
interface will render these as ‘true’ and ‘false’, and
expect input as “t’ or ‘f’ (which will be displayed by the client interface as
“true” or “false”, but be sent to the service as “Y” or “N”).
b.
DATE fields
are transmitted in a standard form (Integer, format yyyymmdd),
whatever the culture settings at either end, but are displayed and managed with
your local culture settings. For
example, BirthDate is transmitted as 19560527, but
with New Zealand culture settings will be displayed and edited as
27/05/1956. With U.S. settings it would
be displayed and edited as 5/27/1956.
c.
TIME fields
are also transmitted as Integers, with format hhmmssmmm. In the client they will be displayed as hh:mm:ss.mmm, e.g
25.678 seconds after 3:45 PM would be displayed as 15:45:25.678. SQL TIME fields can’t hold milliseconds, so
on the server the milliseconds will be rounded up or down to the nearest
second.
For
these reasons, and also because the service cannot
guarantee that the message it receives has come from the web service client
interface, request messages are fully validated by the service before they are
accepted for processing. With good
client-side validation most of the possible errors will have been prevented,
but the cost of repeated validation is a small price to pay for the assurance
it provides. Should an error be detected
in the service it will be reported in the returned Error value.
When
do you Need to Re-create a Client Interface?
If
you have modified your program in a way that doesn’t
change the message formats or operations supported by the service, then you can
generate and compile the COBOL program but you do not need to re-create the
client interface. For example, minor
changes to logic like a different message, or a changed calculation, will have
no effect on the message formats, and you can test your new program with its
client without re-creating the interface.
However, if you change the message format: for example, you change the
list of fields to be sent in either the input or output message, or you add or
remove a method (Update, Add, Delete, etc) compared to the previous message,
then you’ll need to regenerate the interface.
You’ll also need to regenerate the
interface if you change between returning 1 record or several. I generated
program JSPG2 to return 1 EMPLOYEE record, and program JSPG2A to return
6. The difference between 1 and 6 means
that for JSPG2A the EMPLOYEE data is returned in an array, and so the
interfaces are different. Because EMPLOYEE
data is returned as an array for JSPG2A, but not for JSPG2 (even though the
COBOL record structure is defined with OCCURS 1), JSPG2 and JSPG2A require
different interfaces. The interface need
not be re-created if JSPG2A is changed to return a different number, provided that it is > 1.
Note
that, “Array” means something different in the world of COBOL, and
object-oriented languages like Java and C#.
To a COBOL programmer an array is a repeating set of identical
structures mapped to a region of memory, and COBOL programmers can take
advantage of this by redefining the array.
In the client-side world of C# amd Java,
arrays are lists. They are not
necessarily in a contiguous region of memory, so Array(2)
might not follow Array(1) in memory. Fields of the array may be directly within
the array element, more often they are pointers to data stored elsewhere. Elements don’t have
to be the same size. They may even
differ in format. They cannot be
redefined: there is no equivalent of a COBOL REDEFINES clause.
To
Re-create a Client
Interface
With Micro Focus Enterprise Developer: -
In
Solution Explorer, right-click your COBOL project and click Refresh
Annotations.
Select
your program or click [Auto Select], and then click [Refresh]
Delete
the old .svi, .wsbind, and .json objects, e.g.
JSPG2A.svi, JSPG2A.wsbind*, JSPG2AI.json, and JSPG2AO.json
* The .wsbind
may have been moved
Now
recreate the .svi, and wsbind etc. as described
here.
Refresh the the service
interface. To ensure that everything is consistent: -
·
In
Visual Studio, with the COBOL project (in my case TstSQL)
open
·
In
the Solution Explorer window right-click the project and select Refresh
Annotations for Services.
·
A
form like this appears
·
Here
no programs have red exclamation marks, so no further action is necessary. If one or more programs have an exclamation
mark, either select them and click [Refresh], or click [Auto Select] and then
[Refresh] to update them all.
With z/OS: -
[Process]
your program to submit a job that will compile your program and [re-]create the
binding objects including the .json
Copy the two .json files back to
your project folder, e.g. your equivalent of C:\Tutorials\TSTSQL
Using
a Client Interface
The section above, Creating a Client Interface,
dealt with creating the middle section of this diagram. Creating this is simply a matter of clicking
[Client] and then [Create Interface] from the Jazz Workbench with the program
that created the web service (right section, “Mainframe”). If changes are made to the service, you can
re-generate the interface.
You’ll develop a client – a Windows Form, a Web page, or a mobile
App – that communicates with the web service through the interface to use the
interface. This client might be
developed in C#, Java, VB.NET, or other languages. This is the left part of
this diagram.
Clients
will communicate with the interface through properties and methods, which can
be discovered in the usual way. This section
describes how you can write such a client: JSPG2Test is a Windows form that
uses JSPG2Client to communicate with the web service. This section shows how you would write such a
client, using Visual Studio.
If there is user demand for this,
MANASYS could generate prototype clients, like the Windows form used in this
example. These are unlikely to be
anything more than a code template, from which you can extract useful code
snippets, after all, we don’t know what you want to
do. A real client may invoke other web
services, access local data, or services like the client’s current GPS
location.
Getting
Started – Locate or Create a Suitable Project
Client
objects are created within a suitable project – for example, if you want to
create a C# Windows client, then you must have a C# Windows project. For a VB Windows Client you’ll
need a VB Windows project, and so on. If
such a project doesn’t exist, you can create a new
project.
To
create a suitable C# Windows Project: -
1. Open Visual Studio, select
New Project, and choose a suitable template.
I chose Windows Forms App (.NET Core).
Click [Next]
2. On the next form
a. give the project a name (I
used “MyJSvClientTests”),
b. optionally check [ ] Place solution
and Project in the same directory (recommended), and
c. click [Create]. A project is created with these objects: -
3. Right-click Solution ‘MyJSvClientTests’, and select
Add/Existing Project. A Windows Explorer
opens showing you your projects. Click
on folder MyJSv, and then when that folder opens,
click on MyJSv.csproj and then click [Open] : -
The project now looks like this: -
4. Rename Form1 to something
with more meaning. I renamed it to
JSPG2Test: -
a.
Right-click
Form1.cs, click Rename
b.
Change
“Form1” to “JSPG2Test”.
c.
Reply
[Yes] to the message “Would you also like to perform a rename in this project
to all references to the code element ‘Form1’?
d.
Open
the form JSPG2Test and change its Text property from Form1 to JSPG2Test to be
consistent with its object name
5. Right-click the Project (NOT
the Solution) MyJSvClientTests and select Project
Reference. Because we have already
included this project within our Solution, it is the first option: -
Click this checkbox.
Creating
More Forms
I have followed this naming convention as I developed more
tests: my project MyJSvClientTests currently contains
JSPG1Test.cs, JSPG1VTest.cs, JSPG2ATest.cs, JZPG2Test.cs, and JSTIMETest.cs. Each
program uses the corresponding xxxxClient.cs in
project MyJSv.
To add another form, in Solution Explorer right-click your
test project (MyJSvClientTests), and click Add, and
then Form(Windows Form): -
Give the form the name that you want (e.g.) JSPG3DTest,
click [Add]. An empty form appears, it
already has the correct name so you don’t need to
change this.
Initializing
the form
Before we can add buttons to
invoke interface methods, and labels and textboxes to display data, we need to
add some code to the form. We have
already added a reference to project MyJSv in step
#5. Now, with each new test form: -
6.
We
need to instantiate an interface object within
our form. Edit the code for form JSPG2Test (if it is not already open in Visual
Studio, right-click JSPG2Test.cs in Solution Explorer, and click View
Code). Add
using MyJSv;
towards the
top.
7.
Add
static JSPG2Client Jspg2Client
= new JSPG2Client();
where shown in
the code below. Note that we’ve used the same name, but with different case: Jspg2Client is an instance of the class
JSPG2Client.
8. We also add
bool EditMode = true;
The reason for this will become clear
shortly.
The
C# code for our form now looks like this.
I’ve highlighted the statements that I wrote,
the rest was inserted by Visual Studio when I created JSPG2Test: -
using MyJSv;
using System.Windows.Forms;
namespace MyJSvClientTests
{
public partial class JSPG2Test : Form
{
static
JSPG2Client Jspg2Client = new
JSPG2Client();
bool
EditMode = true;
public JSPG2Test()
{
InitializeComponent();
}
}
}
The following notes detail how you create your first form.
Go to Creating Similar Tests to find
some shortcuts to reuse your earlier tests.
Creating
a Client Form
Now
that we’ve created a suitable form object, JSPG2Test, and instantiated the
interface object JSPG2Client as Jspg2Client (same name, different capitalization),
we’re ready to design the form (or web page or app or …) by adding controls
(labels, textboxes, buttons) to communicate with Jspg2Client properties and
methods. As you develop the form, you’ll develop the form’s logic, described in the next section.
In reality you’ll flip-flop between these two
sections, but it’s easier to describe appearance and Form
Logic separately.
Here is a form that I created to test and demonstrate the
interface: -
I’ve created
·
label
fields lblError, lblBrowseCount
and lblReturnCode to display various output fields
returned by the service,
·
textboxes
for fields that can be entered by users and passed to the web service and also returned from the service. I arranged the fields used for access (EMPNO,
WORKDEPT, and SKIP) at the top, and highlighted the two key fields.
·
Access
by WORKDEPT might return several values, for example WORKDEPT=D11 corresponds
to ~ 14 records in my test data. The
form needs scrolling commands as shown to manage this, arranged in a Groupbox so that the control group can be displayed or not
depending on whether scrolling is relevant.
·
lblSex to display the value of the Sex code,
·
lblHttpResponse to display response header information, and lblRawResponse to display the response if the request
fails.
·
a
series of buttons for the methods that the interface supports, plus [Clear] and
[Close].
This
form uses almost all of the data and methods
available, but in a real situation you might use only some of the interface’s
fields and methods. As well as the buttons like btnEnquire
that invoke interface methods, [Clear] empties the form controls, and [Close]
closes it.
How
do you know what data (properties) and methods (operations) are available? You can find out from Intellisense,
or from the source code of the interface if you developed the interface or have
access to it. If you didn’t develop the interface, you
might have been given documentation of its properties and methods.
Intellisense
Within the logic of a control write the name of the service
interface (Jspg2Client) followed by a period.
This name comes from
static JSPG2Client Jspg2Client = new JSPG2Client();
that
we wrote above. Thus we double-click a control, and write
“Jspg2client.” in its event logic:-
private void txtEmpno_TextChanged(object sender, EventArgs
e)
{
{
Jspg2Client.
}
}
As
we type the “.” Intellisense responds by showing you
a list of properties and methods in the interface: -
Source
Code
The source code of the service interface provides
useful data.
1. A few lines from the
beginning you’ll find a definition of struct SetByUser. This provides a list of all the fields that can be changed
by the client: these should become textboxes.
I have named my textboxes txtXxxx, e.g. txtEmpno, and placed a label ahead of them with their name
(EMPNO).
2. A little further down there
is a comment
// Key Properties - fields used by
methods to access records
The following properties are particularly important: they must all be present
in your client program, as they are used to tell the methods which records you
want to work with. For JSPG2Client there
is a field called Skip used to control scrolling, and two fields EMPNO and
WORKDEPT. EMPNO is the primary key of
EMPLOYEE, and WORKDEPT is a duplicate key.
Skip is used when you access the table by WORKDEPT, providing an ability
to handle multiple records with scrolling.
3. Next is a comment
// I/O Data - non-key fields that may be
set for update and add, will be set in response
These properties are general non-key fields that the client might use, and
might change. Like the key properties,
they should become textboxes if you want them.
4. Coded fields and _Value
properties. Some fields in the web
service have been defined as codes: for example SEX is
defined: -
SEX CHAR(1) CAPS CODES(M:Male, F:Female),
The value
which you can enter in the text box is the code – “M” or “F”. Because SEX is defined with CODES, a readonly property SEX_Value is
created which will contain “Male” or “Female”.
Next there are
output fields
// Output data - readonly
properties that are set from response, e.g. JZ_Error
You should put these into labels, not textboxes, because the client can’t
change their value. Of these, Error is
particularly important. If any errors
are detected then text will be returned in this field, and from a normal
response a message like SQL UPDATE/INSERT SUCCESSFUL
will be displayed. The fields JZ_Employee_BrowseCount and JZ_Employee_Return
code are useful to control scrolling. Return Code is another example of a coded
field: it is defined
ReturnCode
CHAR(1) CAPS CODES(' ':' ',W:Warning,E:Error,S:'Serious Error',T:'Terminal Error',
A:Absent,C:Changed,D:Deleted,F:First,I:Inserted, L:Last, N:Nth,U:Unique));
and
there is a ReturnCode_Value property in case you want
to display “Absent”, etc.
5. Following the output fields
are the methods
// Methods. Usually related to Function, e.g. Function CHAR(1) CAPS CODES(E:Enquiry,
U:Update, A:Add, D:Delete) will have
// Enquiry, Update, Add, and Delete methods
This section contains code for each method, like
public bool Enquiry(string PSkip = null,string PEMPNO = null,string PWORKDEPT = null)
and the code to implement this method.
You should not need to be concerned with this implementation, but you
will need to put a Button in your client for each method that you want to use,
and write appropriate code to invoke the method. We’ll see how to do
this later.
Form
Logic - Properties
Double-click
a TextBox and a TextChanged
handler is added. Using Intellisence we can select a Key or I/O property of the
interface, and complete the statement by assigning the textbox’s text value to
this property
private void txtEmpno_TextChanged(object sender, System.EventArgs e)
{
Jspg2Client.EMPNO = txtEmpno.Text;
}
As
values are typed into the textbox they are validated
according to the rules that have been built into the set option for the
Jspg2Client property. You will remember
that EMPNO is numeric, and has range 0 to 999999. txtEmpno_TextChanged
will be invoked whenever we key a value into txtEmpno.Text,
so if we attempt to enter a non-numeric character
we’ll immediately get the error message and return code displayed.
However,
txtEmpno_TextChanged is also triggered when a value
is returned from an Enquiry (or other) method.
We don’t want this, so an if condition is added so that the code is only executed when EditMode is true: -
private void txtEmpno_TextChanged(object sender, EventArgs e)
{
if (EditMode)
{
Jspg2Client.EMPNO = txtEmpno.Text;
}
}
Provided that the value entered obeys this rule the
assignment will accept the value, but if the value is invalid it will be
rejected and the interface sets output fields Error and a return code, so we
write code like this. The two lines setting lblError.text
and lblReturnCode.text will occur many times in the
client, so they’re put into a routine: -
private void txtEmpno_TextChanged(object sender, EventArgs e)
{
if (EditMode)
{
Jspg2Client.EMPNO = txtEmpno.Text;
ShowResponse();
}
}
private void ShowResponse()
{
lblError.Text = Jspg2Client.Error;
lblReturnCode.Text = Jspg2Client.JZ_Employee_ReturnCode + ":" +
Jspg2Client.JZ_Employee_ReturnCode_Value;
}
We
should write similar TextChanged handlers for all of the textboxes.
They will reuse ShowReponse, we don’t need to write this again.
Form Logic – Methods
Every interface will have an Enquiry method, so it’s logical to start with this. Double-click the [Enquiry]
button and a Click handler is added:
private void btnEnquiry_Click(object sender, EventArgs e)
{
}
We
write code here to invoke the interface’s Enquiry method, and handle its
response. We start by writing a
reference to the interface, and selecting the Enquiry method. Intellisense shows
us the parameters that the method requires.
Parameters
are PSkip, PEMPNO, and PWORKDEPT, corresponding to
textboxes txtSkip, txtEmpno,
and txtWorkDept.
Note also that interface methods are functions returning True or False,
as they’re designed to be written as conditions of an
IF statement.
We
add this logic to invoke Jspg2Client.Enquiry: -
private void btnEnquiry_Click(object sender, EventArgs e)
{
if (Jspg2Client.Enquiry(txtSkip.Text,
txtEmpno.Text, txtWorkdept.Text))
{
HandleValidResponse();
}
else
{
ShowResponse();
}
}
If
there is a problem then the method returns False and only the Error and Return
Code properties. However, if the
interface request succeeds a response is received with data in all the
interface’s properties, so we execute HandleValidResponse
to copy the data from these to our client’s controls like txtEMPNO. All of the methods
will have the same action on return, so we change this to
private void btnEnquiry_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.Enquiry(txtSkip.Text, txtEmpno.Text, txtWorkdept.Text));
}
private void HandleResponse(bool Method)
{
if (Method)
{
HandleValidResponse();
}
else
{
ShowResponse();
}
}
If
there is no need to handle scrolling, HandleValidResponse
is just this: -
private void HandleValidResponse()
{
SetFormValues();
}
SetFormValues simply assigns all the interface properties to
corresponding form controls.
private void SetFormValues()
{
EditMode = false;
lblError.Text = Jspg2Client.Error;
lblBrowseCount.Text = Jspg2Client.JZ_Employee_BrowseCount;
lblReturnCode.Text = Jspg2Client.JZ_Employee_ReturnCode + ":" +
Jspg2Client.JZ_Employee_ReturnCode_Value;
txtEmpno.Text = Jspg2Client.EMPNO;
txtWorkdept.Text = Jspg2Client.WORKDEPT;
txtSkip.Text = Jspg2Client.Skip;
txtFirstNme.Text = Jspg2Client.FIRSTNME;
txtMidInit.Text = Jspg2Client.MIDINIT;
txtLastName.Text = Jspg2Client.LASTNAME;
txtPhoneNo.Text = Jspg2Client.PHONENO;
txtHireDate.Text = Jspg2Client.HIREDATE;
txtJob.Text = Jspg2Client.JOB;
txtEdlevel.Text = Jspg2Client.EDLEVEL;
txtSex.Text = Jspg2Client.SEX;
lblSex.Text = Jspg2Client.SEX_Value;
txtBirthDate.Text = Jspg2Client.BIRTHDATE;
txtSalary.Text = Jspg2Client.SALARY;
txtBonus.Text = Jspg2Client.BONUS;
txtComm.Text = Jspg2Client.COMM;
txtCurrency.Text = Jspg2Client.CURRENCY;
txtDeptMgr.Text = Jspg2Client.DEPTMGR;
EditMode = true;
}
It
is written as a subroutine as it will be used for other methods. Note that it starts by setting EditMode = false; and concludes with EditMode = true; so that the assignments don’t execute the code in the TextChanged
handlers. This would not only be
pointless but could have some undesirable side effects such as recording the
field as Changed (= set by user) causing it to be included in a following
Update.
Managing
Scrolling
Program
JSPG2 retrieves Employee records using either Employee’s primary key, EMPNO, or
WORKDEPT. EMPNO may retrieve zero or 1
record, WORKDEPT may retrieve zero or many records. To handle scrolling I’ve
placed buttons and the Skip textbox on the form within a groupbox:
-
When the enquiry uses the duplicate key, WORKDEPT, these
scrolling controls will appear if there is more than one Employee for this
WORKDEPT value, and the scrolling buttons will be active if there are more
records in the Next or Previous direction.
Two output fields are important for controlling scrolling: -
·
JZ-Employee-BrowseCount is set to 0 for access by unique key (EMPNO),
and to the number of records that could be retrieved for non-unique access
(WORKDEPT). We do not want the scrolling
controls if BrowseCount is 0 or 1.
·
If
scrolling applies, then the return code, defined as
JZ-Employee-ReturnCode CHAR(1) CAPS CODES(' ':' ',W:Warning,E:Error,S:'Serious Error',T:'Terminal Error',
A:Absent,C:Changed,D:Deleted,F:First,I:Inserted, L:Last, N:Nth,U:Unique));
can tell us whether where at the beginning or end of the
scrolling list. For ReturnCode
F (First) we don’t want the Previous
[ < ] and First [ << ] buttons active, for
Return code L (Last) we don’t want Next [ > ]
or Last [ >> ].
Note 1.
Field names in Jazz or COBOL that have hyphens will have underscores in
C# and other client languages. Thus,
these fields are called JZ_Employee_BrowseCount and JZ_Employee_ReturnCode in C#.
Note
2. BrowseCount is calculated differently for SQL (=DB/2 etc.)
and VSAM. See Browsecount.
Note 3.
It is a bad idea to use a
scroll bar with a web service. Dragging
a scroll bar causes a flurry of request/responses to be sent to/from the web
service.
We’ll need code to be executed with Enquiry to control
whether we see the scrolling commands, and whether the Next or Previous buttons
are active. But the scrolling buttons,
also need this code, so this logic is put into HandleValidResponse:
-
private void HandleValidResponse()
{
int BrowseCount;
int.TryParse(Jspg2Client.JZ_Employee_BrowseCount, out BrowseCount);
if (BrowseCount < 2)
{
gbxScroll.Visible = false;
}
else
{
gbxScroll.Visible = true;
if (Jspg2Client.JZ_Employee_ReturnCode == "F")
{
btnPrev.Enabled = false;
btnFirst.Enabled = false;
}
else
{
btnPrev.Enabled = true;
btnFirst.Enabled = true;
}
if (Jspg2Client.JZ_Employee_ReturnCode == "L")
{
btnNext.Enabled = false;
btnLast.Enabled = false;
}
else
{
btnNext.Enabled = true;
btnLast.Enabled = true;
}
}
SetFormValues();
}
Because this web service may require scrolling, the
interface has been generated with ReadNext, ReadLast, ReadFirst and ReadPrev methods.
IntelliSense discovers these, and we add methods like this: -
private void btnNext_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.ReadNext(txtSkip.Text));
}
private void btnPrev_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.ReadPrev(txtSkip.Text));
}
private void btnLast_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.ReadLast());
}
private void btnFirst_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.ReadFirst());
}
Update,
Delete, and Add
In
the same way we discover that Update, Add, and Delete require a single
argument, EMPNO, which is Employee’s primary key, so except for the method name
we write mostly the same code for each.
Here is the Update logic: -
private void btnUpdate_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.Update(txtEmpno.Text));
}
Update
must follow an enquiry, either a single-record enquiry using the primary key
(EMPNO) and the [Enquiry] button, or a scrolling enquiry with ReadNext or ReadPrev. The enquiry will have returned a checksum
which is used to prevent invalid updates.
If, between your enquiry and update another user changes the record then
a different checksum will be calculated: this difference will be detected
within the interface, and your update rejected.
NB: since this snap was recorded the check message has changed: it would
now be
GET check failure: EMPLOYEE changed or not read
To
update a record we’ll enter new data in various
textboxes, then click the [Update] button.
Here I’ve removed MIDINIT by entering “null”
(must be lower case), set JOB to “Manager”, and DEPTMGR to T (for True).
Click
[Update] and the record is updated, and new values displayed: -
Delete is identical except that it
invokes Jspg2Client.Delete. Like
Update, it must follow an enquiry: -
private void btnDelete_Click(object sender, EventArgs e)
{
HandleResponse(Jspg2Client.Delete(txtEmpno.Text));
}
Add requires some extra
logic. If it were the same as Update
then it would be misleading: Update sends the record key (EMPNO) and the changed
data to the service to the service. With
the Add method you want all the data that you see displayed in the
form’s controls to be included in the new record, whether you’ve
edited it or whether it has come from a preceding read. Before the Add the btnAdd_Click
event therefore sets the Jspg2Client property corresponding to each of the
textboxes except the primary key (EMPNO) and Skip. Unlike HandleValidResponse/SetFormValues these assignments are NOT surrounded by EditMode = false; and EditMode = true; because the point of these
assignments is to set the relevant Changed flag.
private void btnAdd_Click(object sender, EventArgs e)
{
// Input all textboxes (except 1ry
Key and Skip), and set their Changed flag
Jspg2Client.WORKDEPT = txtWorkdept.Text;
Jspg2Client.FIRSTNME = txtFirstNme.Text;
Jspg2Client.MIDINIT = txtMidInit.Text;
Jspg2Client.LASTNAME = txtLastName.Text;
Jspg2Client.PHONENO = txtPhoneNo.Text;
Jspg2Client.HIREDATE = txtHireDate.Text;
Jspg2Client.JOB
= txtJob.Text;
Jspg2Client.EDLEVEL = txtEdlevel.Text;
Jspg2Client.SEX
= txtSex.Text;
Jspg2Client.BIRTHDATE = txtBirthDate.Text;
Jspg2Client.SALARY = txtSalary.Text;
Jspg2Client.BONUS = txtBonus.Text;
Jspg2Client.COMM
= txtComm.Text;
Jspg2Client.CURRENCY = txtCurrency.Text;
// Now add the new record
HandleResponse(Jspg2Client.Add(""));
}
Clear
and Close
These are basic methods that do not involve the web
service.
Clear simply sets all the textboxes to blank. This must be done with EditMode = false; to prevent error messages
from blank required fields
private void btnClear_Click(object sender, EventArgs e)
{
EditMode = false;
lblError.Text = "";
lblBrowseCount.Text = "";
lblReturnCode.Text = "";
txtEmpno.Text = "";
txtWorkdept.Text = "";
txtSkip.Text = "0";
txtFirstNme.Text = "";
txtMidInit.Text = "";
txtLastName.Text = "";
txtPhoneNo.Text = "";
txtHireDate.Text = "";
txtJob.Text = "";
txtEdlevel.Text = "";
txtSex.Text = "";
txtBirthDate.Text = "";
txtSalary.Text = "";
txtBonus.Text = "";
txtComm.Text = "";
txtCurrency.Text = "";
EditMode = true;
}
Close is
private void btnClose_Click(object sender, EventArgs e)
{
this.Close();
}
Adding another
Control
As
your system evolves there can be a need to add extra controls to your client
form. For example, field Employee.StartTime was added to the Employee record: -
DEFINE EMPLOYEE
SQL DATA(
…
DEPTMGR BOOLEAN,
STARTTIME TIME);
With
the web service JSPG2.jzz (=>JSPG2.cbl) regenerated, and the interface
JSPG2Client.js regenerated, our client program JSPG2Test continues to work
exactly as before, ignoring this new field. To use it, we need to add a control
to the JSPG2Test form. Here I’ve added a label with the field’s name, and a textbox
called “txtStartTime”: -
Now I wire it up so that values can
be displayed and updated. Double-click
the textbox, opening a _TextChanged handler. Write similar logic within this as for other
textboxes: -
private
void txtStartTime_TextChanged(object
sender, EventArgs e)
{
if
(EditMode)
{
Jspg2Client.STARTTIME = txtStartTime.Text;
ShowResponse();
}
}
Next,
find the routine SetFormValues. Add an assignment for StartTime:
-
private void SetFormValues()
{
EditMode = false;
…
txtStartTime.Text = Jspg2Client.STARTTIME;
lblHttpResponse.Text = Jspg2Client.StatusCode.ToString()
+ "(" + Jspg2Client.StatusCode_Value + "), Success:" +
Jspg2Client.IsSuccessStatusCode + ", Reason:" + Jspg2Client.ReasonPhrase;
lblRawResponse.Text = Jspg2Client.RawResponse;
EditMode = true;
}
For coded fields like SEX then there would also have been an
assignment to the relevant label field: -
txtSex.Text = Jspg2Client.SEX;
lblSex.Text
= Jspg2Client.SEX_Value;
but
this is not relevant to StartTime.
An
assignment from the textbox to the interface property is added to the btnAdd_Click method, to ensure that an Add will include
this value: -
private void btnAdd_Click(object sender, EventArgs e)
{
// Validate all textboxes (except
1ry Key and Skip), ensuring that they will be included in following Add because
Changed will have been set
…
Jspg2Client.CURRENCY = txtCurrency.Text;
Jspg2Client.STARTTIME = txtStartTime.Text;
// Now add the new record
HandleResponse(Jspg2Client.Add(""));
}
Add StartTime to btnClear_Click: -
private void btnClear_Click(object sender, EventArgs e)
{
EditMode = false;
…
txtCurrency.Text = "";
txtStartTime.Text = "";
EditMode = true;
}
Creating
Similar Tests
Having
developed one test, you can save time on your later tests. Here I am developing a test for web service
JSPG3D, which is a single-table enquiry reading JSPG3D to read the Department
table. At this point I have created an
empty form called JSPG3DTest, and I’ve added the code
described in initializing the form. Now I
want to add controls to this form, which are similar to
the controls on a previous test, JSPG1Test which read the Employee table.
1.
I
opened form JSPG1Test.cs (design view), and selected the part of the form
containing the controls I wanted.
2.
I
copy/pasted these controls into form JSPG3DTest
3.
I
then edited the form to
a. Change text to the
appropriate field names, e.g. “EMPNO” becomes “DEPTNO”
b. Change the names of controls
to appropriate names where necessary, e.g. “txtEmpno”
becomes “txtDeptno”
c. Add extra controls as
necessary: where Employee had one alternate index, Department has two
Now
the form looks like this, with the controls that I wanted, but no logic beyond
that from initializing the form: -
Now
the controls are wired up as described above.
Click on the relevant control, and add similar code. Sometimes you can simply Copy/Paste code from
the copied form (e.g. [Close]), sometimes it is worthwhile to copy/paste and
then edit the code, but often it is just as easy to create new code following
the patterns above.
Client
Projects with Multiple Forms
In Using a Client Interface
project MyJSvTests was created with a single form,
JSPG2Test. Starting this project with Visual Studio automatically opens form
JSPG2Test. Now you want to test another
interface? You could of course create
another project, but if your new client is another C# form then you may prefer
to add this form to MyJScTests.
When
you create a C# forms project, one of the objects created in it is Program.cs, containing this code: -
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace MyJSvClientTests
{
static class Program
{
/// <summary>
/// The main entry point for the
application.
/// </summary>
[STAThread]
static void Main()
{
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new JSPG2Test());
}
}
}
My
next task was to test JSPG2A, a version of JSPG2 that returns several Employee
records. If I add
Application.Run(new JSPG2ATest());
to this, then
the project will first open JSPG2test, then when I close this it will open
JSPG2ATest. This worked well when I was
testing for differences in behaviour between JSPG2 and JSPG2A. When I was working with just one of the programs I’d comment out the Application.Run that I didn’t want. I didn’t bother
creating a menu. Currently the logic in MyJSvClientTests.Program
is like this: -
static void Main()
{
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new
JSPG1Test());
//Application.Run(new
JSPG1VTest());
//Application.Run(new
JSPG2Test());
//Application.Run(new
JSPG2ATest());
Application.Run(new JSTimeTest());
}
For complete
details of the JSPG2A test, see Programs used as
Examples
Parent-Child
Services
Introduction:
Test Data for JSPG3
So far we have dealt with services that handle one type of
record, either for Enquiry only, or with Update, Add, and Delete
functions. We can also create services
that handle a parent record and a set of child records. We’ll illustrate
this with program JSPG3 which, like JSPG2, is a web service capable of updating
DB2 data. It works with two records from
the IBM Sample database, Department, and Employee, defined to MANASYS like
this: -
*#
Created from Table:DEPARTMENT,
Schema:ROBERTBW10, Database:Sample by JazzUser at 23/03/2019 7:52:20 AM
DEFINE DEPARTMENT SQL DATA(
DEPTNO CHAR(3) CAPS REQUIRED KEY,
DEPTNAME VARCHAR(36) REQUIRED,
MGRNO CHAR(6) PIC '999999' DKEY 'XDEPT2',
ADMRDEPT CHAR(3) CAPS REQUIRED DKEY 'XDEPT3',
LOCATION CHAR(16));
*#
Created from Table:EMPLOYEE,
Schema:ROBERTBW10, Database:Sample by JazzUser at 26/03/2019 4:25:46 PM
COPY Department;
DEFINE EMPLOYEE SQL DATA(
EMPNO CHAR(6) PIC '999999' REQUIRED KEY,
FIRSTNME VARCHAR(12) REQUIRED,
MIDINIT CHAR (1),
LASTNAME VARCHAR(15) REQUIRED,
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
PHONENO CHAR(4) PIC '9999',
HIREDATE DATE,
JOB CHAR(8),
EDLEVEL SMALLINT REQUIRED,
SEX CHAR(1) CAPS CODES(M:Male, F:Female),
BIRTHDATE DATE,
SALARY MONEY(9,2) MIN 0,
BONUS MONEY(9,2) MIN 0,
COMM MONEY(9,2) MIN 0,
CURRENCY CHAR(3),
DEPTMGR BOOLEAN);
As
the initial comments indicate, these MANASYS record definitions were initially
created using Import from SQL, but then the definitions were enhanced with Jazz
properties like PIC '999999', CAPS, CODES(M:Male, F:Female),
and others to provide better editing and make programming easier.
Department
has primary key DEPTNO, and two duplicate keys, MGRNO and ADMRDEPT. We can access the table by any of these keys,
for example: -
db2 => Select * from
Department where admrdept = 'A00'
DEPTNO DEPTNAME MGRNO ADMRDEPT LOCATION
------
------------------------------------ ------ -------- ----------------
A00 SPIFFY COMPUTER SERVICE DIVISION 000010 A00 Head Office
B01 Planning. 000020 A00 Building G
C01 INFORMATION CENTER 000030 A00 -
D01 DEVELOPMENT CENTER - A00
-
E01 SUPPORT SERVICES 000050 A00 -
5 record(s) selected.
Employee records are related to Department through WorkDept: -
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
Of the 5 departments in the list above, some have employees:
-
db2 => Select count(*), workdept from Employee
where workdept in (Select DEPTNO from department
where admrdept = 'A00') Group by workdept
1 WORKDEPT
----------- --------
30 A00
1 B01
4 C01
1 E01
4 record(s) selected.
Creating
Web Service JSPG3
Here
we’re creating a service that will return a Department
record, and 0 to 10 employees (at a time) who work in that department: -
|
|
|
[Finish] creates a Jazz web service
program, JSPG3, that that can read and update Department much as program JSPG2
could read and update Employee. But
unlike JSPG2, with each Department the related Employee records are also read:
the [Finish] process deduces the relationship between the two tables from the EXISTS DEPARTMENT.DEPTNO
property
of EMPLOYEE.WORKDEPT. The web service message definition, and then
the program JSPG3, is displayed in the Jazz Workbench.
Compared to a single-record service like JSPG2
1.
The
Enquiry and Update logic includes code to read the related Employee records: -
…
WHEN
(Enquiry);
…
GET
DEPARTMENT KEY(DEPARTMENT.DEPTNO OR
DEPARTMENT.MGRNO OR
DEPARTMENT.ADMRDEPT)
SAVESUM OJSPG3.JZ-DEPARTMENT.Checksum;
PROCESS
EMPLOYEE WHERE(EMPLOYEE.WORKDEPT =
DEPARTMENT.DEPTNO)
SAVESUM OJSPG3.JZ-EMPLOYEE.Checksum;
END
PROCESS EMPLOYEE
RESPOND OJSPG3;
END
GET DEPARTMENT
RESPOND OJSPG3;
…
2.
New
functions Child and PChild are included.
WHEN
(Child);
* Create a new EMPLOYEE record
GET
EMPLOYEE FREEKEY
CREATE;
ACCEPT
(IJSPG3.JZ-DEPARTMENT.DEPTNO,IJSPG3.JZ-EMPLOYEE.*) EXCEPT(EMPLOYEE.EMPNO) MESSAGE OJSPG3.Error;
EMPLOYEE.WORKDEPT
= DEPARTMENT.DEPTNO;
GET
DEPARTMENT KEY(DEPARTMENT.DEPTNO);
END
GET DEPARTMENT
RESPOND OJSPG3;
END
GET EMPLOYEE CREATE RESPOND OJSPG3;
WHEN
(PChild);
* Process a selected child record.
* Generated logic is only a basic update:
change this for your situation, e.g. "Process Order".
ACCEPT
(EMPLOYEE.EMPNO=IJSPG3.EMPNO) MESSAGE OJSPG3.Error;
GET
EMPLOYEE KEY(EMPLOYEE.EMPNO) UPDATE CHECKSUM IJSPG3.JZ-EMPLOYEE.Checksum;
ACCEPT
(IJSPG3.JZ-DEPARTMENT.DEPTNO,IJSPG3.JZ-EMPLOYEE.*) EXCEPT(EMPLOYEE.EMPNO) MESSAGE OJSPG3.Error;
EMPLOYEE.WORKDEPT
= DEPARTMENT.DEPTNO;
GET
DEPARTMENT KEY(DEPARTMENT.DEPTNO);
END
GET DEPARTMENT
RESPOND OJSPG3;
END
GET EMPLOYEE UPDATE RESPOND OJSPG3;
If either of these functions are used the logic will
start by creating or reading an Employee record, and
then it will directly read the corresponding Department record. The initial Enquiry might have read one of
several records and you could scroll forward and back through these, but after
a Child or PChild function parent scrolling will be
lost until the next Enquiry.
We click [Process] to convert this to COBOL.
·
If
MANASYS is configured to work directly with ZOS, a job will be submitted to ZOS
that will compile the COBOL, and generate the JSON and Binding files.
·
If
MANASYS is configured to work with Micro Focus, the COBOL is written directly
into the relevant folder of the COBOL project.
We click the button to the right of [Process] and control is passed to
the MF COBOL project where we compile it, and create the JSON and binding
object as previously described.
Once
the JSON has been created (and for ZOS users, copied back to the Jazz Workbench
environment) the service can be tested with general test software such as
Postman or ReadyAPI.
Here is a ReadyAPI test of program JSPG3: -
This
test shows that the service is working, and when invoked with ADMRDEPT = “A00”
it will return the first of 5 qualifying DEPARTMENT record, plus the first 10
of 30 records of employees working in this department.
Creating
and testing JSPG3Client
Creating
a client interface, JSPG3Client.cs, is as described previously for program
JSPG2. With program JSPG3 displayed in
the Jazz workbench, click [Client].
To
create a client to invoke this, I’ve created
JSPG3Test.cs starting by creating this C# Form, copying and renaming controls
from previous forms (see Creating Similar
Tests) and hooking up the initialization: -
The
top part of this form is very like JSPG2Test except that it reads and updates
Department instead of Employee. The
bottom part of this form is also like JSPG2Test, showing Employee fields and
controls. The controls are a little bit
different, and note that it has its own scrolling controls. At this stage we have a form, but without any
code-behind logic to make the buttons do anything, or the textboxes and labels
to display any data.
Next I wired up the textboxes to
provide get and set methods, and wired up all the buttons. In the top (Department) part of the form, the
scrolling buttons are wired up to the Scroll methods and Enquiry, Update, Add,
Delete, Clear, and Close are wired up as in JSPG2, except for the obvious
differences in object names.
In
the bottom (Employee) section the scrolling buttons are wired up to a set of ChildScroll commands (ReadNextChild,
ReadLastChild, ReadPrevChild,
and ReadFirstChild), [Add Employee] is wired up to
Child, [Process Employee] to PChild, and [Clear
Employee] to logic that clears the Employee fields except for WorkDept. WorkDept is a special field: it defines the joining
relationship, and the Jazz code
PROCESS EMPLOYEE
WHERE(EMPLOYEE.WORKDEPT =
DEPARTMENT.DEPTNO)
…
ensures that
any Employee handled by JSPG3 MUST have a WORKDEPT value = DEPNO. When we created
the service the option “Xcpt Join” omitted the
joining fields from Employee, so Workdept is not in
the response message. In test JSPG3Test
I created a textbox for Workdept, but I wired it up
to DEPTNO, and made it read only.
Here
is a test. I have just clicked [Clear]
to clear the whole form, then set ADMRDEPT to a00 and clicked [Enquiry]
Scrolling
through the 5 Department records is, like JSPG2, relatively slow, as each Next
or Previous requires a request/response.
The response returns the first 10 employee records, and JSPG3Test
displays the first. Scrolling through
the Employee records behaves like program JSPG2A: there is a slow response when
we first ask for the 11th record, or the 21st, but when
Next or Previous requires a record that has already been read, the response is
instantaneous. Whenever we scroll the
Department Records, the employee list is cleared and reset.
Clicking
various action buttons will Update, Delete, or Add Department records, while
clicking [Add Employee] or [Process Employee] invokes the Child or PChild methods to add or process the Employee records. As noted above, using either of these two
buttons will fix the Department record so you need to click [Enquiry] to resume
Department scrolling.
For
complete details of the JSPG3 test, see Programs
used as Examples
Appendices
Programs
used as Examples
MANASYS
Jazz programs
|
Program |
Function |
Comment |
|
JSPG1 |
DB2
Enquiry |
Generated
web service, JSON, Uses Database Sample, Table Employee, max = 6. |
|
JSPG1V |
VSAM
Enquiry |
Like
JSPG1, but uses VSAM file Custf |
|
JSPG2 |
DB2
Update |
Generated
like JSPG1 except Update, max = 1 |
|
DB2
Update |
Like
JSPG2 except max = 6 |
|
|
JSTIME |
Returns
Server’s Time |
A
very basic program, with no file or database I/O |
|
DB2
Update |
Parent/Child
Update (Department/Employee) |
You can click the links to
see the MANASYS test programs used. They
will open in Notepad, copy them to a .jzz file if you
have MANASYS Jazz available.
Client Interfaces
Files will open with Notepad
Test Programs
|
JSPG2A |
|||
|
JSPG3 |
Returning Multiple Records
Programs JSPG2 and JSPG2A have been generated to perform the same task, but JSPG2 was defined with Max=1 and JSPG2A with Max=6. The process of defining the interface JSPG2AClient and the test form JSPG2ATest is exactly as described above for JSPG2, and both tests behaved identically except for scrolling: for JSPG2A, ReadNext ([>] button) was instant (< 1 millisecond) except for every 6th record when a Request/Response was required. Each Request/Response took approximately 3 seconds with my test environment, and I couldn’t find any statistically-significant difference between request/responses from JSPG2 and JSPG2A even though JSPG2A’s messages were larger. While returning large output messages than necessary seems wasteful, there is also hidden waste like having to read-and-skip unwanted records to get to the one that you want, so my conclusion is that you should set Max to as large a value as you might conceivably need.
My use of Max=6 is NOT a balance between excessively large messages and other overheads. 6 was chosen because my priority was developing code that would silently handle the situation where Max was not large enough to get all the records. For a real situation with data like mine I’d have set Max=14. Similarly, with program JSPG3 I set the number of child records to 10, even though I had ensured that for DEPTNO=A00 there were 30 EMPLOYEE records. In a real situation I would have set the number to 30.
Logic used when Max > 1
When Max > 1 then the interface saves the first n records in a list. Thus the first WorkDept=D11 Enquiry saved the first 6 records. On reading the 7th record the next 6 records are added to this list, and so on until the last record (known from BrowseCount) is read. Backward scrolling ([<] and [<<]) is always instant, while forward scrolling ([>]) is instant except for every 6th record. Scroll to end ([>>]) might use several request/responses.
The client’s record list is maintained until there is another [Enquiry]. If a record is updated then the updated record replaces the original record in the list. Added records are added to the list and BrowseCount incremented. Deleted records are deleted from the list and Browsecount reduced, but the deleted record remains displayed until the next scrolling command or [Enquiry].
In the following appendices you’ll see significant differences in JSPG2Client/JSPG2AClient logic, but none in JSPG2Test/JSPG2ATest.
Measuring Response Time
I measured response times by adding code like this to the interface. If relevant, you should do the same to check out your situation: -
JSPG2Client and JSPG2AClient.Scroll.
private bool Scroll(int Increment, string PSkip = null,string PWORKDEPT = null)
{
Stopwatch stopwatch
= new Stopwatch();
stopwatch.Start();
…
stopwatch.Stop();
Debug.Print("Scroll Stopwatch: ms=" + stopwatch.ElapsedMilliseconds.ToString());
return DoRead(PSkip,
"", PWORKDEPT);
}
JSPG2Client
and JSPG2AClient.DoRead. It was
necessary to change the generated statement
return = RequestResponse();
to bool Result = RequestResponse();
so that the Stop time could be reported.
public bool DoRead(string PSkip = null,string PEMPNO = null,string PWORKDEPT = null)
{
…
Stopwatch stopwatch
= new Stopwatch();
stopwatch.Start();
bool Result = RequestResponse();
stopwatch.Stop();
Debug.Print("RequestResponse Stopwatch: ms=" + stopwatch.ElapsedMilliseconds.ToString());
return Result;
}
Browsecount
Browsecount is calculated differently for SQL
and for VSAM. For SQL it is always
accurate, because the SQL logic starts with SELECT COUNT(*), e.g.
005440 SELECT COUNT(*) INTO :OJSPG1.JZ-Employee-BrowseCount FROMJSPG1
005450 EMPLOYEE WHERE WORKDEPT LIKE :JZLIKE JSPG1
There
is no equivalent of COUNT(*) with VSAM. Since the point of BrowseCount
is to control scrolling, and for this purpose it is sufficient if it is greater
than the number read unless all the browsed records have been read, the value
of BrowseCount for VSAM is : -
If
the browse list has been read to the end, BrowseCount
is accurate.
If
the browse list has not been read completely, BrowseCount
is 1 greater than the number of records that have been read.
Example: Program JSPG1V is like program JSPG1, but
instead of reading data from DB2 table EMPLOYEE it reads a VSAM file CustF. JSPG1V was
generated with Max=6, so: -
Enter
Name = Barnes and click [Read]. The
first 6 records are read, and BrowseCount = 7: -
Scrolling forward [>] is
instant until the 7th record is reached when the next 6 records are
read, and BrowseCount becomes 13.
Last record, [>>], read
another 6 records, and so might need to be clicked several times to really get
to the end. With my test data this
browse returns 23 records, so three [>>] clicks are needed to get to the
end.
This logic was designed for VSAM to avoid the need to read all the VSAM records with every browse enquiry just to calculate BrowseCount accurately.
Jazz Message Definitions
This is the message definition for program JSPG2A. Note that it contains three main parts, but also refers to other definitions through COPY statements. To deduce the full data rules, you need to follow the Assign relationships, for example to understand that IJSPG2A.EMPNO must be numeric in the range 1-999999 you need to look up EMPLOYEE.EMPNO. This definition gives Jazz all the information that it needs to create the interface.
*#
Last Updated by JAZZUSR at 14/11/2021 2:43:27 PM
*#
You may edit this definition: right-click the 'WEBSERVICE' keyword of the
PROGRAM statement.
COPY EMPLOYEE;
COPY TYPES;
DEFINE MyJSv-JSPG2A
SYSTEM DATA([Not in COBOL
INPUT VARCHAR(7) VALUE 'IJSPG2A',
OUTPUT VARCHAR(7) VALUE 'OJSPG2A',
MType
CHAR(4) VALUE 'JSON',
Template CHAR(8) VALUE '@JSF1Upd',
URL VARCHAR(42) VALUE 'http://localhost:9003/cics/services/JSPG2A');
DEFINE IJSPG2A
SERVICE INPUT DATA(
Function CHAR(1) CAPS CODES(E:Enquiry,U:Update,A:Add,D:Delete) VALUE Enquiry,
JZ-EMPLOYEE-Skip
SMALLINT VALUE 0 RANGE(0:999),
JZ-EMPLOYEE
GROUP,
EMPNO CHAR(6) ASSIGN EMPLOYEE.EMPNO,
FIRSTNME
CHAR(12) ASSIGN EMPLOYEE.FIRSTNME,
MIDINIT
CHAR(1) ASSIGN EMPLOYEE.MIDINIT,
LASTNAME
CHAR(15) ASSIGN EMPLOYEE.LASTNAME,
WORKDEPT
CHAR(3) ASSIGN EMPLOYEE.WORKDEPT,
PHONENO
CHAR(4) ASSIGN EMPLOYEE.PHONENO,
HIREDATE
CHAR(9) ASSIGN EMPLOYEE.HIREDATE,
JOB CHAR(8) ASSIGN EMPLOYEE.JOB,
EDLEVEL
CHAR(7) ASSIGN EMPLOYEE.EDLEVEL,
SEX CHAR(1) ASSIGN EMPLOYEE.SEX,
BIRTHDATE
CHAR(9) ASSIGN EMPLOYEE.BIRTHDATE,
SALARY
CHAR(15) ASSIGN EMPLOYEE.SALARY,
BONUS CHAR(15) ASSIGN EMPLOYEE.BONUS,
COMM CHAR(15) ASSIGN EMPLOYEE.COMM,
CURRENCY
CHAR(3) ASSIGN EMPLOYEE.CURRENCY,
DEPTMGR
CHAR(5) ASSIGN EMPLOYEE.DEPTMGR,
Checksum
CHAR(40),
END GROUP);
DEFINE OJSPG2A
SERVICE OUTPUT DATA(
Error VARCHAR(80),
JZ-EMPLOYEE-ReadTo SMALLINT VALUE 0,
JZ-EMPLOYEE-NbrReturned SMALLINT
VALUE 0,
JZ-EMPLOYEE-BrowseCount SMALLINT
VALUE 0,
JZ-EMPLOYEE
(6) GROUP,
JZ-EMPLOYEE-ReturnCode LIKE Types.ReturnCode,
EMPNO LIKE EMPLOYEE.EMPNO
ASSIGN EMPLOYEE.EMPNO,
FIRSTNME
LIKE EMPLOYEE.FIRSTNME
ASSIGN EMPLOYEE.FIRSTNME,
MIDINIT
LIKE EMPLOYEE.MIDINIT
ASSIGN EMPLOYEE.MIDINIT,
LASTNAME
LIKE EMPLOYEE.LASTNAME
ASSIGN EMPLOYEE.LASTNAME,
WORKDEPT
LIKE EMPLOYEE.WORKDEPT
ASSIGN EMPLOYEE.WORKDEPT,
PHONENO
LIKE EMPLOYEE.PHONENO
ASSIGN EMPLOYEE.PHONENO,
HIREDATE
LIKE EMPLOYEE.HIREDATE
ASSIGN EMPLOYEE.HIREDATE,
JOB LIKE EMPLOYEE.JOB
ASSIGN EMPLOYEE.JOB,
EDLEVEL
LIKE EMPLOYEE.EDLEVEL
ASSIGN EMPLOYEE.EDLEVEL,
SEX LIKE EMPLOYEE.SEX
ASSIGN EMPLOYEE.SEX,
BIRTHDATE
LIKE EMPLOYEE.BIRTHDATE
ASSIGN EMPLOYEE.BIRTHDATE,
SALARY
LIKE EMPLOYEE.SALARY
ASSIGN EMPLOYEE.SALARY,
BONUS LIKE EMPLOYEE.BONUS
ASSIGN EMPLOYEE.BONUS,
COMM LIKE EMPLOYEE.COMM
ASSIGN EMPLOYEE.COMM,
CURRENCY
LIKE EMPLOYEE.CURRENCY
ASSIGN EMPLOYEE.CURRENCY,
DEPTMGR
LIKE EMPLOYEE.DEPTMGR
ASSIGN EMPLOYEE.DEPTMGR,
Checksum
CHAR(40),
END GROUP);
Note that the output record is
defined with a dimension, even for program JSPG1. This value corresponds to the Max value given
for Employee when the service was generated,
so for JSPG2A it is 6. For JSPG2 this
would be 1.
Here is the definition of the
EMPLOYEE record, referenced in LIKE and ASSIGN
properties: -
*#
Last Updated by JAZZUSR at 31/08/2020 1:33:28 PM
*#
Created from Table:EMPLOYEE,
Schema:ROBERTBW10, Database:Sample by JazzUser at 26/03/2019 4:25:46 PM
COPY Department;
DEFINE EMPLOYEE SQL DATA(
EMPNO CHAR(6) PIC '999999' REQUIRED KEY,
FIRSTNME VARCHAR(12) REQUIRED,
MIDINIT CHAR (1),
LASTNAME VARCHAR(15) REQUIRED,
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
PHONENO CHAR(4) PIC '9999',
HIREDATE DATE,
JOB CHAR(8),
EDLEVEL SMALLINT REQUIRED,
SEX CHAR(1) CAPS CODES(M:Male, F:Female),
BIRTHDATE DATE,
SALARY MONEY(9,2) MIN 0,
BONUS MONEY(9,2) MIN 0,
COMM MONEY(9,2) MIN 0,
CURRENCY CHAR(3),
DEPTMGR BOOLEAN);
Message and Field Names
A Jazz container definition like
that above has a standardized appearance.
It contains three DEFINE statements, and it may reference other definitions directly or
indirectly through COPY statements. The first
definition,
DEFINE MyJSv-JSPG2 SYSTEM DATA([Not in COBOL
is not generated into the COBOL (because it has type SYSTEM) but it gives vital information to the [Client] generation, including
the names of the input and output messages.
The name of this definition is always Service-Program. The input message will be named by prefixing
the program name with “I”, and the output message will
use prefix “O”.
Most of the field names in the input
and output messages are user-defined. In
the messages above, most of the fields have come from the EMPLOYEE record, and
use the same names as there. However there are a few other fields with particular
names. Most have the form JZ-xxxx-Field, e.g. JZ-Employee-Skip
which is a field used to control browsing. Jazz will not permit you to name your own
fields starting with JZ. There are a few
fields that do not follow this form: do not use these as your own field names in
web services: -
FUNCTION This is an input field defined by Jazz logic.
ERROR An output field that may
contain an error message
CheckSum Both
Input and Output: this is used to manage pseudo-locking ensuring update
integrity.
If the message doesn’t contain ERROR and ReturnCode (here with the form JZ-xxxx-ReturnCode) , they will be
generated into the client anyway as they are used by the client to report local
validation issues.
Messages – COBOL, JSON, C#,
and Binding
We wrote a web service
program in MANASYS Jazz, and when we clicked [Process]
this was turned into COBOL. The COBOL
program will contain data definitions based on the Jazz-format definitions
above. For example, this is the request
message, IJSPG2: -
003360 01
IJSPG2.
JSPG2
003370 03 JZ-Function PIC X VALUE 'E'. JSPG2
003380 03 JZ-Employee-Skip PIC S9(4) COMP-5 VALUE 0. JSPG2
003390 03 JZ-Employee. JSPG2
003400 05 EMPNO PIC X(6) VALUE SPACES. JSPG2
003410 05 FIRSTNME PIC X(12) VALUE SPACES. JSPG2
003420 05 MIDINIT PIC X VALUE SPACES. JSPG2
003430 05 LASTNAME PIC X(15) VALUE SPACES. JSPG2
003440 05 WORKDEPT PIC XXX VALUE SPACES. JSPG2
003450 05 PHONENO PIC XXXX VALUE SPACES. JSPG2
003460 05 HIREDATE PIC X(9) VALUE SPACES. JSPG2
003470 05 JOB PIC X(8) VALUE SPACES. JSPG2
003480 05 EDLEVEL PIC X(7) VALUE SPACES. JSPG2
003490 05 SEX PIC X VALUE SPACES. JSPG2
003500 05 BIRTHDATE PIC X(9) VALUE SPACES. JSPG2
003510 05 SALARY PIC X(15) VALUE SPACES. JSPG2
003520 05 BONUS PIC X(15) VALUE SPACES. JSPG2
003530 05 COMM PIC X(15) VALUE SPACES. JSPG2
003540 05 JZ-CURRENCY PIC XXX VALUE SPACES. JSPG2
003550 05 DEPTMGR PIC XXXXX VALUE SPACES. JSPG2
003560 05 Checksum PIC X(40) VALUE SPACES.
JSPG2
To get the request message
the COBOL program contains
005700 EXEC CICS
JSPG2
005710 GET CONTAINER(JZInputContainer) INTO(IJSPG2) JSPG2
005720 RESP(JZ-RESPONSE) JSPG2
005730 END-EXEC.
JSPG2
Similarly, there will be a
COBOL definition of the response, which will be sent back to the client with
021250 EXEC CICS
JSPG2
021260 PUT CONTAINER(JZContainerName) FROM(OJSPG2) JSPG2
021270 RESP(JZ-RESPONSE) JSPG2
021280 END-EXEC.
JSPG2
But the client is not
COBOL! The messages must be converted to
a standard form that can be understood, whatever the language the client
uses. For this to happen, after program JSPG2
was compiled a “binding object” is produced to convert the messages between
COBOL-format and JSON, the most popular standard form, and JSON descriptions of
the request and response messages were produced.
With Jazz configured for
z/OS, this all happens on the mainframe as a result of
JCL steps that are automatically inserted into the job that compiles the
COBOL. With Jazz configured to work with
Micro Focus Enterprise Developer, this is done through the
dialog described here.
Request
message as JSON.
This
is the JSON generated from the COBOL for the request message
{
"$schema" : "http:\/\/json-schema.org\/draft-04\/schema#",
"title" : "JSPG2",
"description" : "Micro Focus Enterprise Developer - This generated
JSON schema document is provided 'as is' and without any warranties of any
kind, and may be used by licensee solely for the purposes of describing a REST
API. Micro Focus shall not be responsible for and hereby disclaims any
liabilities that may result from licensee's use of or modifications to this
generated JSON schema document.",
"type" : "object",
"properties" :
{
"JSPG2" :
{
"type" : "object",
"properties" :
{
"IJSPG2" :
{
"type" : "object",
"properties" :
{
"JZ_Function" :
{
"type" : "string",
"maxLength" : 1
},
"JZ_Employee_Skip" :
{
"type" : "integer"
},
"JZ_Employee" :
{
"type" : "object",
"properties" :
{
"EMPNO" :
{
"type" : "string",
"maxLength" : 6
},
"FIRSTNME" :
{
"type" : "string",
"maxLength" : 12
},
"MIDINIT" :
{
"type" : "string",
"maxLength" : 1
},
"LASTNAME" :
{
"type" : "string",
"maxLength" : 15
},
"WORKDEPT" :
{
"type" : "string",
"maxLength" : 3
},
"PHONENO" :
{
"type" : "string",
"maxLength" : 4
},
"HIREDATE" :
{
"type" : "string",
"maxLength" : 9
},
"JOB" :
{
"type" : "string",
"maxLength" : 8
},
"EDLEVEL" :
{
"type" : "string",
"maxLength" : 7
},
"SEX" :
{
"type" : "string",
"maxLength" : 1
},
"BIRTHDATE" :
{
"type" : "string",
"maxLength" : 9
},
"SALARY" :
{
"type" : "string",
"maxLength" : 15
},
"BONUS" :
{
"type" : "string",
"maxLength" : 15
},
"COMM" :
{
"type" : "string",
"maxLength" : 15
},
"JZ_CURRENCY" :
{
"type" : "string",
"maxLength" : 3
},
"DEPTMGR" :
{
"type" : "string",
"maxLength" : 5
},
"Checksum" :
{
"type" : "string",
"maxLength" : 40
}
}
}
}
}
}
}
}
}
RequestJSPG2.cs
Just
as we use COBOL definitions within the web server program JSPG2, within the C#
program JSPG2Client we convert the JSON into a hierarchy of C# classes. Here is the request definition, as it will be
used within JSPG2Client. Except for
naming, there is no difference between this and RequestJSPG2A.cs
namespace MyJSv
{
public class RequestJSPG2
{
public class JSPG2_
{
public class IJSPG2_
{
public string JZ_Function { get; set; }
public int JZ_Employee_Skip { get; set; }
public class JZ_Employee_
{
public string EMPNO { get;
set; }
public string FIRSTNME { get;
set; }
public string MIDINIT { get;
set; }
public string LASTNAME { get;
set; }
public string WORKDEPT { get;
set; }
public string PHONENO { get;
set; }
public string HIREDATE { get;
set; }
public string JOB { get;
set; }
public string EDLEVEL { get;
set; }
public string SEX { get;
set; }
public string BIRTHDATE { get;
set; }
public string SALARY { get;
set; }
public string BONUS { get;
set; }
public string COMM { get;
set; }
public string JZ_CURRENCY { get;
set; }
public string Checksum { get;
set; }
}
public JZ_Employee_
JZ_Employee { get; } = new JZ_Employee_();
}
public IJSPG2_ IJSPG2
{ get; } = new IJSPG2_();
}
public JSPG2_ JSPG2
{ get; } = new JSPG2_();
}
}
Note the way in which the lower-level classes are made
addressable by naming the original class with a _, e.g. JSPG2_ and then following this class
with
public JSPG2_ JSPG2 { get;
} = new JSPG2_();
From
public class IJSPG2_ this corresponds directly to the JSON schema. The outer two layers are added to ensure that
the structure confirms to the JSON that is received, otherwise the JSON would needs to be text-edited on input and output before being
serialised/de-serialised. Statements
can now be generated into JSPG2Client reflecting this structure, for example
Request.JSPG2.IJSPG2.JZ_Employee.EMPNO = _EMPNO;
ResponseJSPG2.cs
Like
RequestJSPG2.CS, this maps the hierarchical structure of the response, and has
a couple of levels at the top to reflect the JSON structure: -
namespace MyJSv
{
public class ResponseJSPG2
{
public class JSPG2Response_
{
public class OJSPG2_
{
public class JZ_Error_
{
public int JZL_Error { get; set; }
public string JZD_Error { get; set; }
}
public JZ_Error_
JZ_Error { get;
} = new JZ_Error_();
public int JZ_Employee_ReadTo { get;
set; }
public int JZ_Employee_NbrReturned { get; set; }
public int JZ_Employee_BrowseCount { get; set; }
public class JZ_Employee_
{
public string JZ_Employee_ReturnCode { get; set; }
public string EMPNO { get;
set; }
public class FIRSTNME_
{
public int JZL_FIRSTNME { get;
set; }
public string JZD_FIRSTNME { get;
set; }
}
public FIRSTNME_ FIRSTNME
{ get; } = new FIRSTNME_();
public string MIDINIT { get;
set; }
public class LASTNAME_
{
public int JZL_LASTNAME { get;
set; }
public string JZD_LASTNAME { get;
set; }
}
public LASTNAME_ LASTNAME
{ get; } = new LASTNAME_();
public string WORKDEPT { get;
set; }
public string PHONENO { get;
set; }
public int HIREDATE { get;
set; }
public string JOB { get;
set; }
public int EDLEVEL { get;
set; }
public string SEX { get;
set; }
public int BIRTHDATE { get;
set; }
public float SALARY { get;
set; }
public float BONUS { get;
set; }
public float COMM { get;
set; }
public string JZ_CURRENCY { get;
set; }
public string DEPTMGR { get;
set; }
public string Checksum { get;
set; }
}
public JZ_Employee_
JZ_Employee { get; } = new JZ_Employee_();
}
public OJSPG2_ OJSPG2
{ get; } = new OJSPG2_();
}
public JSPG2Response_ JSPG2Response
{ get; } = new JSPG2Response_();
}
}
Response
JSPG2A
Wheras the requests for JSPG2 and JSPG2A are the same, there is a
significant difference between their requests.
There is nothing in the JSPG2 structure allowing JZ_Employee
to repeat, and references like this in JSPG2Client don’t have a subscript.
_EMPNO =
Response.JSPG2Response.OJSPG2.JZ_Employee.EMPNO;
The
equivalent in JSPG2AClient is generated as
_EMPNO = Response.JSPG2AResponse.OJSPG2A.JZ_Employee[IXT1Sub].EMPNO;
The
definition of JZ_Employee is generated as below to
support this: -
public List<JZ_Employee_>JZ_Employee { get; set;} = new List<JZ_Employee_>();
Understanding
the Client Interface
We
started with a web service, written in MANASYS Jazz and converted to COBOL and
JSON objects which were compiled on a “Mainframe”,
represented in the right section of this diagram, repeated from above. Clicking [Client] and then [Create Interface]
created the middle section, the interface.
The
interface is generated as C#, using .NET Core, and so should run in a wide
variety of environments: Windows, UNIX, Linux, IOS, Android, … The actual
client apps may be written in Java, C#, VB, or other technologies. This section explains the structure and
function of the interface, which is based on Template
@JazzClient.cs. You can see
examples of generated interfaces at https://www.jazzsoftware.co.nz/Docs/JSPG2Client.cs.txt
and https://www.jazzsoftware.co.nz/Docs/JSPG2AClient.cs.txt.
It
contains a number of sections
1.
Private
// Private - objects that are not known
outside the Client object
Here you find things that are NOT communicated to the Client
Program.
·
The
actual Request and Response messages,
private RequestJSPG2 Request = new RequestJSPG2(); // Actual request message
private ResponseJSPG2 Response = new ResponseJSPG2(); // Actual response message
·
Changed. A struct, SetByUser,
contains a list of all the properties that can be set by the client. It is instantiated with
private SetByUser
Changed = new SetByUser();
The interface
keeps track of which fields have been changed since a response, so that an
Update can send only changed fields.
·
Private
fields like Function and Checksum which are managed within the interface.
2.
Key
Properties
// Key Properties - fields used by
methods to access records
Here you find properties that are used by methods to specify
which records are to be handled, in this case EMPNO, WORKDEPT, and Skip.
·
Program
JSPG2 updates the Employee table, which has been defined with primary key EMPNO
·
WORKDEPT
is a duplicate key
·
Because
WORKDEPT may specify several Employee records, Skip also appears here to
control scrolling.
Property EMPNO shows the typical structure of a
property. There is a private variable
_xxx, e.g. “_EMPNO” that the client can’t see, and a
public property “EMPNO” that it can. The
value of the private variable is available with get,
and its value is set through code like that below
private string _EMPNO = null;
public string EMPNO // => Request.EMPNO
{
get => _EMPNO;
set
{
Changed.EMPNO = true;
_EMPNO = null;
if (value == "")
{
_ERROR =
"Value
required";
_JZ_Employee_ReturnCode = "E";
return;
}
_EMPNO = IsInt(value,
0, 999999, "EMPNO");
Request.JSPG2.IJSPG2.JZ_Employee.EMPNO = _EMPNO;
}
}
The set code starts by setting the appropriate Changed flag, and
then checks that the value entered is valid.
For required fields like EMPNO validation starts by checking that a
value has been given. See PHONENO below to see how optional fields are handled.
This is followed by validation that depends on the field’s definition – EMPNO
must be an integer, in the range 0 to 999999.
Finally, the value is assigned to the request message.
3.
I/O
Data
// I/O Data - non-key fields, will be set
in Add, Update requests
Like Key fields, these communicate with the Client through get and set methods like that for
EMPNO. PHONENO is an example of an
optional field: unlike EMPNO which was required, a PHONENO value can be absent,
or “null”. For
SQL optional fields “null” (lower case) will cause the database field to be set
to null.
Note that “null” cannot be assigned as the value of a string
field, although “Null” and other variations with at least one upper case
character are treated as normal string values.
Thus
_PHONE = "null";
will pass "null" back in the input message, but this value is recognised by
the web service as a special value, and instead of assigning 'null' to EMPLOYEE.PHONENO, the field will be set to
NULL, meaning that it has no value (not even “NULL”).
private string _PHONENO = null;
public string PHONENO // => Request.PHONENO
{
get => _PHONENO;
set
{
Changed.PHONENO = true;
_PHONENO = null;
if (value == "" || value == "n" || value == "nu" || value == "nul")
return;
if (value == "null")
_PHONENO
= "null";
else
_PHONENO
= IsInt(value,
0, 9999, "PHONENO");
Request.JSPG2.IJSPG2.JZ_Employee.PHONENO = _PHONENO;
}
}
4.
Output
From
the Jazz Message Definitions you can
see that there are several fields like ERROR in the output message that have no
equivalent in the input message. These provide only a get method, so the Client can’t change
them.
private string _ERROR = null;
public string _ERROR // Readonly
{
get => _ERROR;
}
If
displayed label controls will usually be used.
5.
Value
properties
Within the properties you’ll see a
few output properties named xxxx_Value immediately
following the xxxx property. _Value properties exist
when
1. A property relates to a field
defined to MANASYS with CODES.
2. A property relates to a field
that has a meaning defined by the system.
Example 1. The SEX
property is followed by the SEX_Value property: -
public string SEX_Value // => Request.SEX_Value
{
get
{
if (_SEX == "M")
return "Male";
if (_SEX == "F")
return "Female";
return "";
}
}
This
is because SEX is defined with CODES: -
SEX CHAR(1) CAPS CODES(M:Male, F:Female),
Example 2. The
output field JZ_Employee_ReturnCode is followed by JZ_Employee_ReturnCode_Value. There is also an example, StatusCode_Value
in the Standard Response Properties, which returns HttpCode
as a string, “OK”
instead of 200.
3.
Functions
This
section contains the routines required by set ,
such as IsInt which is used to check that an input
value is an integer, InList to check that a value is
in a list (like SEX), and so on. IsInt is typical, it starts by initializing ERROR and
return code properties, then it checks Value to see if it is valid. If not, the ERROR will be set to an
appropriate message and the return code set to “E”.
private string IsInt(string Value, int MinVal, int maxval, string FieldName)
{
_ERROR = "";
_JZ_Employee_ReturnCode = "";
if (Value == "") return "0";
int IX = 0;
if (!int.TryParse(Value,
out IX))
{
_ERROR = FieldName + " Value is Not Numeric";
_JZ_Employee_ReturnCode = "E";
}
else if (IX < MinVal || IX > maxval)
{
_ERROR = FieldName + " Value out of range";
_JZ_Employee_ReturnCode = "E";
}
return Value;
}
4.
Standard
Response Properties
All
html messages have some information in their headers, and so the interface
provides several output-only properties returning this: -
public int StatusCode // returns HttpStatusCode
as a number
public string StatusCode_Value // returns HttpStatusCode as a string,
e.g. 200 => “OK”
public string IsSuccessStatusCode// True if the request is successful
public string ReasonPhrase // returns the reason for failure (or not).
public string RawResponse // blank except when unsuccessful request
5.
RequestResponse
A
standard method that is used by all methods except [Clear] and [Close]. The request message is converted to JSON and
sent, the response received and converted back, and then the response values
are assigned to the output properties.
6.
Methods
a.
JSPG2Client
Because JSPG2 is controlled by Function, which is defined
Function CHAR(1) CAPS CODES(E:Enquiry,U:Update,A:Add,D:Delete)
VALUE Enquiry,
there
will be Enquiry, Update, Add, and Delete methods.
Because
scrolling is possible, logic will be based on the @ReadScroll.cs template, and
so scrolling methods ReadNext, ReadLast,
ReadPrev, and ReadFirst
will be generated into JSPG2Client.
Methods
get their input values from parameters, not properties, allowing them to check
that the values that they are given are valid (for example, EMPNO hasn’t changed for an Update). Typically they check
their arguments and then invoke RequestResponse,
either directly or through another method (e.g. Scroll and DoRead).
Update
will put changed values into the request, but ignore any that haven’t been changed.
JSPG2Client will have saved CHECKSUM from the previous Enquiry, this is
returned in the request and will be checked by the service, and the update
rejected if it differs from the recalculated value.
So
will Add, but JSPG2Test ensures that all textboxes except the primary key
(EMPNO) and Skip are marked as changed.
A blank EMPNO is passed in the message, so the service will find the
next free key. Browsecount
will be incremented.
Delete
only needs the primary key to delete a record, and like Update will return the
Enquiry’s Checksum to be checked.
Result = RequestResponse(false);
is used so that
the deleted record remains displayed in the response. Browsecount will be
reduced.
For detail, see https://www.jazzsoftware.co.nz/Docs/JSPG2Client.cs.txt
b.
JSPG2AClient
JSPG2AClient differs from JSPG2Client in only one way: it returns several EMPLOYEE records at a time. This has had minor effects on the Jazz and C# data definitions, but it has a major effect on the code generated for JSPG2AClient, particularly the Enquiry, Update, Add, and Delete methods.
For an enquiry by WorkDept 6 records are read and the first returned to the client (JSPG2ATest), but all 6 are saved in a list. Assignment statements need to specify a subscript, initially 0, to assign data from the first record to the properties returned to the client. Scrolling within the 6 records is very quick, because it’s just a subscript change and doesn’t require a request/response.
If scrolling goes beyond the first 6, the next 6 are read and added to the list.
The list is updated to reflect Update, Delete, and Add, so that it reflects the new database. For Delete and Add Browsecount will change.
For detail, see https://www.jazzsoftware.co.nz/Docs/JSPG2AClient.cs.txt.
7.
Routines
The
last section of the interface contains routines that are used by methods.
ResetChanged resets all the SetByUser flags,
marking all input/output fields as unchanged.
AssignResponseToProperties assigns data from the
response message to the interface properties, whether private (like CheckSum), Output (like Error), or Input/Output.
ClearRequest sets all request fields to null, preventing data carry-over
AddPrivateFieldsToRequest adds the fields to the
request that are not shared with the client.
Currently this is only CheckSum.
Road Map
MANASYS
Jazz Version 16.1.230 was the first build to incorporate client interface
generation, although only as a proof-of-concept. The feature was tested with a web service
program JSPG2 which updates table EMPLOYEE, from IBM’s Sample DB2
database. I added two extra fields,
Currency to prove that column names that are COBOL reserved words can be
handled, and DeptMgr to prove that Boolean fields can
be handled across the COBOL and Client worlds.
Build 16.2.239 added: -
·
Enquiry-only
web services.
·
Web
services that return multiple records – e.g. several EMPLOYEE records – in a
message. Timing experiments showed that
there was no measurable time difference in returning a single-record or
multi-record web service, and scrolling through a list of records was instant
compared to ~3 seconds per record for each request/response.
·
Add
and Delete methods as well as Read and Update.
Add and Delete functions are optional.
·
Update
methods may have Max > 1, for update as well as enquiry only
·
VSAM
records as well as DB2.
Build 16.2.240: -
·
Related
Fields. When a web service is generated
from a definition including fields using EXISTS, like
WORKDEPT CHAR(3) CAPS DKEY 'XEMP2' EXISTS DEPARTMENT.DEPTNO,
the
generation dialog offers the option of selecting fields from DEPARTMENT. If (e.g.) DEPARTMENT.DEPTNAME
is selected then this is included in the output message as an output-only
field.
Build 16.3.244: -
·
Client
Interfaces and web services handling parent/child record hierarchies
Build 17.1.296: -
·
TIME data was implemented in Jazz,
with appropriate display formats, validation, and TIME arithmetic. This applies for COBOL web services, but to
clients TIME data is
simply an INTEGER, and there is no special
client-side validation or display format.
Build 17.1.306: -
·
TIME data is displayed with an
appropriate format, and correctly validated (hh is
0-23, mm is 00-59, ss is 00-59, and mmm is 000-999)
We
are looking for early adopters to join us on this exciting journey: not only
will they get some immediate benefits from the features that MANASYS Jazz
already offers, they will be very influential in setting our development
priorities.
Possible
development (in no particular order, will be selected
based on user interest and support): -
·
Support
conversational web services. An
implementation working like ASP.NET “Viewstate” has
been defined that would allow data to be handed from one request/response to
the next. Like ASP’s Viewstate
the data will be encrypted so that even if seen by the client it won’t be able to be understood or changed.
·
Variable
Function Codes. Currently update
programs must use E(Enquiry), U(Update), A(Add), and D(Delete). A configuration option could be provided
allowing users to use R(Read) or I(Inquiry) instead of E(Enquiry), and so
on. Or letters/words in languages other
than English.
·
Check
that all the data types in IBM’s Sample Database that are supported by Jazz*
can be handled
* Jazz doesn’t
support BLOB, CLOB, and National data.
MANASYS
Jazz doesn’t yet handle interface definition for SQL records with multi-part
keys (e.g. PROJACT).
·
Support
VSAM groups
and arrays (dimensions), and redefinition
·
Handle
browsing by multiple fields: Compound key, also two or more alternate indexes.
·
Support
Max=*, where the number is unknown until run time.
·
More
flexible record sequences. Messages could pass records with a record-format
indicator, allowing much more flexible record sequences than at present.
·
Allow
local validation logic to be defined, for example checking that a credit card
number has the correct format including check digit, allowing users to
duplicate the function of CHECKR properties in the service.
·
Client-side
reporting. MANASYS Jazz can generate
report programs that run on the mainframe to produce a report, but even with
the Report Designer these output reports in a single font. It should be possible to have a web service
produce a file that is sent to the client from which a report could be produced
with variable fonts and colours, as when software like Crystal Reports is used. The ideal would be to provide dialogs that
with data-aware interfaces allowing the input data to be selected, and dragged
to the report, much like the Report Designer but with variable fonts.
·
Sample
Clients. The design and this document
anticipate that MANASYS could generate a client in C#, VB, or Java, for Windows
or a Web page. It is not expected that
this client will be any more than an initial prototype, like the sample
JSPG2Test Windows Form. It will provide
useful code snippets that can be used in the client that the user actually develops, but it is not currently possible for
MANASYS Jazz to know what the user actually wants. For example, the client may
need to access other web services, local databases, or API’s
like GPS location data. We have
considered providing options that, when you generate an interface, you can
check one or more of the Client options: -
This
could generate a sample client with code like that described above, in the
option(s) that you choose. This will
need to be validated with each client type, e.g. C# Windows Form, C# Web
Program, Visual Basic, Java … and so on.
We
could provide sample clients intended to provide initial code for users to
start with, but we expect that they will need significant editing to meet
actual requirements, and we’re not sure if this is
worth doing. We have no way of knowing
what you actually want the client to do, which might
access local data and other API’s (for example, GPS location), interact with
other web services, and be part of a larger conversation involving
authentication and data passing from step to step.