Task List

Containers have Task Lists which are the actual components or modules to be added, deleted, or changed for a particular unit of work.

To select a Container from the Container List screen, type S next to the desired Container (for example, PLAY000002) and press Enter. The Task List screen for that Container is displayed (Task List for Container PLAY000002).

Task List for container

ASSIGNMENT         PLAY000002: IVP2 - TEST COMPILES         Row     1 of    10
Command ===>                                                  Scroll ===> CSR
                                                                     More -->
+-----------------------------------------------------------------------------+
| Select(/) Add Approve Close Join Reset Show/Hide Work ++/--                 |
+-----------------------------------------------------------------------------+
    Type     Name     Lev Op A User     Date MM DD Time Status
    ________ ________ ____ __ _ ________ __________ _____ ____________________
__   COB      TPROG01 PRD P    USER001 2022-05-09 14:36
__   COB      TPROG02 PRD P    USER001 2022-05-09 14:36
__   COB      TPROG03 PRD P    USER001 2022-05-09 14:36
__   COB      TPROG04 PRD P    USER001 2022-05-09 14:36
__   COB      TPROG05 PRD P    USER001 2022-05-09 14:36
__   COB      TSUBR01 PRD P    USER001 2022-05-09 14:35
__   COB      TSUBR02 PRD P    USER001 2022-05-09 14:35
__   COB      TSUBR03 PRD P    USER001 2022-05-09 14:35
__   COB      TSUBR04 PRD P    USER001 2022-05-09 14:35
__   COB      TSUBR05 PRD P    USER001 2022-05-09 14:35
------------------------------- Bottom of List -------------------------------

Container PLAY000002 contains ten Tasks (or components). A Task is a handle for a specific version of a component and its related objects. A Task may have associated documentation, DBRMs, compile and link parms, output listings, and change impact data. The Task is the visible object on this list, while these other components are associated behind the scenes.

Task List entries are sorted by module Type, then Name. The User column displays the UserID of the person who last updated the module, on the displayed date and time. In the preceding figure, USER001 is working in this Task List. Generally, the application developer or analyst puts Tasks in Assignments, but it could be anyone assigned to this work.

The following table describes the Task List Column:

Column	Description
Type	8-character acronym that determines object treatment within Code Pipeline
Name	short object name or handle
Lev	module’s current level in the change cycle
Op	last update operation performed on this module
A	special action field, such as D to Delete module from Production
User	UserID of the person performing the last update operation
Date	date and time of the last update operation
Status	Code Pipeline message area

Scroll right to see more columns of information, including internal version, based upon version, associated Release, and so on.

The Tasks are in different data sets and files, but Code Pipeline gives a logical view of all these modules in one Task List, so it is easier to track and manage work regardless of where a Task actually resides on the system, or who is working on it.

Filtering the Task List

The following figure shows the Task List filtered by Type COB to show only COBOL programs. All of the column headers are filters to subset information. Try filters on any Code Pipeline column to see how this works.

Filtered Task List

ASSIGNMENT         PLAY000001: IVP1 – LOAD                  Row     1 of    10
Command ===>                                                  Scroll ===> CSR
                                                                     More -->
+-----------------------------------------------------------------------------+
| Select(/) Add Approve Close Join Reset Show/Hide Work ++/--                 |
+-----------------------------------------------------------------------------+
    Type     Name     Lev Op A User     Date MM DD Time Status
    COB_____ ________ ____ __ _ ________ __________ _____ ____________________
__   COB      TPROG01 PRD TL   USER001 2022-05-09 13:58
__   COB      TPROG02 PRD TL   USER001 2022-05-09 13:58
__   COB      TPROG03 PRD TL   USER001 2022-05-09 13:58
__   COB      TPROG04 PRD TL   USER001 2022-05-09 13:58
__   COB      TPROG05 PRD TL   USER001 2022-05-09 13:58
__   COB      TSUBR01 PRD TL   USER001 2022-05-09 13:57
__   COB      TSUBR02 PRD TL   USER001 2022-05-09 13:57
__   COB      TSUBR03 PRD TL   USER001 2022-05-09 13:57
__   COB      TSUBR04 PRD TL   USER001 2022-05-09 13:57
__   COB      TSUBR05 PRD TL   USER001 2022-05-09 13:57
------------------------------- Bottom of List -------------------------------

Sorting the Task List

The Task List makes work easy to view and manage. To sort the Task List on any column, place the cursor on the column header and press Enter. In the following figure, the Lev column is selected. Sorting on the Status column would display any error messages at the top of the sorted list.

Sorting can also be done from the Command line by typing SORT followed by the column header on which to sort the Task List and pressing Enter. For example, entering SORT Lev will alphanumerically sort the Task List using the entries in the Lev column.

Sorting Task List by Lev

ASSIGNMENT         PLAY000003: TEST COMPILES                Row     1 of     6
Command ===>                                                  Scroll ===> CSR
                                                                     More -->
+-----------------------------------------------------------------------------+
| Select(/) Add Approve Close Join Reset Show/Hide Work ++/--                 |
+-----------------------------------------------------------------------------+
    Type     Name     Lev Op A User     Date MM DD Time Status
    ________ ________ ____ __ _ ________ __________ _____ ____________________
__   COB      TPROG01 DEV1 G    USER001 2022-05-09 15:50
__   COB      TPROG03 QA   G    USER001 2022-05-09 15:42
__   COB      TSUBR01 QA   G    USER001 2022-05-09 15:40
__   COB      TSUBR02 QA   G    USER001 2022-05-09 15:41
__   COB      TSUBR03 QA   G    USER001 2022-05-09 15:42
__   COB      TPROG02 STG1 G    USER001 2022-05-09 15:37
------------------------------- Bottom of List -------------------------------

The Task List is more than just a convenient way to organize work and view the components that belong to an Application work request/project. The Task List is the actual user interface for every Code Pipeline operation, from Checkout through Promote to Production.

Task List operations

Code Pipeline users perform most of their job functions from the Task List. The Task List display is a shortcut to various tools, so it makes it quick and easy to invoke the right tool at the right time, without the need to know the file names.

View/browse module

For example, to view or browse a module, type B in the line command field of any row in a Task List and press Enter. The data set or filename shown at the top of the screen will be different for different types of modules or for different levels in the change cycle. The screen to view a module will be similar to that shown in the following figure. In this case, ISPF BROWSE is invoked automatically, because the module being viewed is a PDS member.

View/browse module

   Menu  Utilities  Compilers  Help
-------------------------------------------------------------------------------
BROWSE    ISPW.PLAY.PRD.CLST(TREXX01)              Line 0000000000 Col 001 080
Command ===>                                                  Scroll ===> CSR
********************************* Top of Data **********************************
/* REXX */
username = sysvar('sysuid')
say '<KEEP>'username
say '<KEEP>Roses Are Red'
say '<KEEP>    Violets are Blue'
say '<KEEP>ISPW is Great'
say '<KEEP>    and so are you!'
exit
******************************** Bottom of Data ********************************

Edit a module

To select a Task List object for editing, type S in the line command field next to it and press Enter.

Important

Modules may only be edited when they are in the lowest level of the change cycle. Edit requests at upper levels are rejected.

In the following example, Code Pipeline invokes ISPF EDIT because the module is in a PDS, but Code Pipeline invokes different editors depending on the module type. For example, a company may choose to invoke the SlickEdit product instead of the standard ISPF Editor for COBOL programs.

Edit module

  File Edit Edit_Settings Menu Utilities Compilers Test Help
-------------------------------------------------------------------------------
EDIT       ISPW.PLAY.DEV1.COB(TSUBR02) - 01.00             Columns 00001 00072
Command ===>                                                  Scroll ===> CSR
****** ***************************** Top of Data ******************************
000001 000100 IDENTIFICATION DIVISION.
000002 000200 PROGRAM-ID.    TSUBR02.
000003 000300 AUTHOR.        COMPUWARE ISPW TRAINING.
000004 000400 DATE-WRITTEN. JANUARY 24TH, 1996.
000005 000500 DATE-COMPILED.
000006 000600
000007 000700********************************************************
000008 000800* THIS PROGRAM IS A TRAINING PROGRAM
000009 000900*      CALLED FROM    TPROG02
000010 001000*      WITH COPYLIB   TCPYB02 (LINKAGE AREA)
000011 001100* ======================================================
000012 001200* ISPW (TM)
000013 001300* COPYRIGHT (C) 1986-2016 COMPUWARE CORPORATION.
000014 001400* UNPUBLISHED RIGHTS RESERVED UNDER THE COPYRIGHT
000015 001500* LAWS OF THE UNITED STATES.
000016 001600*
000017 001700* ======================================================
000018 001800*                   MODIFICATION LOG
000019 001900*

Real-time Task List updating

After every update operation (for example, Edit, Generate, or Promote), the Task List statistics are refreshed so it’s obvious who did what operation and when. Because this screen is simply a dynamic display of the underlying Code Pipeline database data, every Code Pipeline user sees the statistics data in real time.

For example, the fourth entry on the Task List screen shown in the following figure, indicates that user USER001 updated the COBOL program module TSUBR02 at 09:14 on May 10, 2022.

Updated module

ASSIGNMENT         PLAY000003: TEST COMPILES                Row     1 of     7
Command ===>                                                  Scroll ===> CSR
                                                                     More -->
+-----------------------------------------------------------------------------+
| Select(/) Add Approve Close Join Reset Show/Hide Work ++/--                 |
+-----------------------------------------------------------------------------+
    Type     Name     Lev Op A User     Date MM DD Time Status
    ________ ________ ____ __ _ ________ __________ _____ ____________________
__   COB      TPROG01 DEV1 G    USER001 2022-05-09 15:50
__   COB      TPROG03 QA   G    USER001 2022-05-09 15:42
__   COB      TSUBR01 QA   G    USER001 2022-05-09 15:40
__   COB      TSUBR02 DEV1 S    USER001 2022-05-10 09:14
__   COB      TSUBR02 QA   G    USER001 2022-05-09 15:41
__   COB      TSUBR03 QA   G    USER001 2022-05-09 15:42
__   COB      TPROG02 STG1 G    USER001 2022-05-09 15:37
------------------------------- Bottom of List -------------------------------

Task List functions

With Code Pipeline, every development and support function a person needs to do can be done from this Task List interface. Users may Edit modules, compare versions of modules, generate executables, run scripts, debug and trace code, view batch job output, write code documentation, and promote components through test environments—all from the Code Pipeline Task List interface.

Task List help screen

The following figure shows the Help for the Task List screen and lists the line commands for the various Code Pipeline operations available. Type HELP on the Command line and press Enter (or press PF1) from anywhere in Code Pipeline to see Help at any time.

Task List help screen

                         TASK LIST OPERATIONS
Command ===>

Task List operations are entered in the input fields alongside the
respective tasks. The following operations are presented if selected:

                            STANDARD LINE COMMANDS

A    Add duplicate Task to Task List       N    Add Task-specific Notes entry
AX   Display component xref info           OK   Flag module as done, etc.
B    Browse module                         P    Promote module to next level
C    Checkout/copy module                  PR   Printoff a module (hard copy)
CM   Compare modules or libraries          Q    Q/QM/QP/QW - task information
CU   Cleanup 'in process' flags            RE   Rename module to temporary name
D    Delete Task and module from list      S    Select/Edit module
EX   Execute a foreground function         SU   Submit a batch job
FB   Fallback/backout Prod updates         T    Transfer Task to other Assign
G    Generate (compile/link/bind)          V    Component version list
GI   Generate Impacts (not yet avail.)     W    Work list (alternate views)
H    See Task event history                X    Reject/regress module or action
I    Initiate Deploy(Implement) Module/set

                   Press ENTER for Additional Line Commands

Each of the Code Pipeline operations shown in the preceding figure is covered in Main Menu Option P: Container and Task Lists.