Index Home

How to crud combined object

Introduction	Table description	Main principles	The YCOMBD class
The YCOMB class	The YCOMB representation	The YCOMB_CSTD script	The YCOMB_RSTD script

Introduction

In version 6 platform, a "Combined Object" is a type of object where a unique table containing a key with two components has multiple records associated with a given value of the first key component.

In this mode, the screen has a header and a grid.
* The header includes the first component of the key and additional fields with the same value for all records.
* The grid displays a row for each record with the same first key value.

While the generation of the CRUD code for this type of version 6 object is not automated, the new version 7 supervisor enables the creation of these objects as explained in the following example:

Table description

The table 'YCOMB [YCO]' to be handled has the following structure (technical columns are not listed):

Column	Type	Description	Place
YGRP	Character 10	Group	Header
YNAM	Character 80	Group description	Header
YSGRP	Character 5	Group member	Line
YTEXT	Character 40	Member text	Line
YDATE	Date	Member Date	Line
YNUM	Decimal 9.2	Member value	Line

'YCO0' is the unique key in the table. This key has no duplicates and is made up of two components: YGRP+YSGRP.

The principles of the CRUD on a Combined Object

The principles of handling a Combined Object are the following:

The CRUD by itself is defined in the table and a class called 'YCOMBD' has been created. Any business rule associated with this table update is defined with no direct attached representation.
An interface class named 'YCOMB' and its representation has been created for the user interface management. They run:
- The query based on a list of the first key component.
- A collection of 'YCOMBD' instances. Every instance is a line attached to a given header value.
The AREAD, AINSERT, AUPDATE, and ADELETE methods on this interface class invoke the CRUD methods of the 'YCOMBD' class within a loop that runs through all the records.

The 'YCOMBD' class definition

This class has the following characteristics:

It is Persistent, based on the 'YCOMB' table.
The class index is 'YCO0' (YGRP+YSGRP).
The Creation, Update, Read, and Deletion standard methods are available.
The following properties are present : YGRP, YNAM, YSGRP, YTEXT, YDATE, YNUM, CREDATTIM, UPDDATTIM, AUUID, CREUSR, and UPDUSR.
In the Mapping tab, all the CRUD check boxes are selected.

As there are no particular controls on this class, there is no script associated with the class; however, one can be added if necessary.

The 'YCOMB' class definition

This class has the following characteristics:

It is Interface typed, with a key called 'YGRP'.
A collection called 'YCOMBD' is declared with the following characteristics:
- Minimum=0 and Maximum=0
- Insertion, Deletion, Sorting, and Addition check boxes selected.
A script called 'YCOMB_CSTD' has been added.
The Creation, Read, Update, and Deletion standard methods are available.
The following fields are present on the Properties tab:
- 'YGRP' and 'YNAM' are available on the header.
- 'YCOMBD', which is an instance of the 'YCOMBD' collection, is present in this collection.

The 'YCOMB' representation

This representation has the following characteristics:

It is associated with the class 'YCOMB', having 'YCOMB' as an instance name.
Managed behaviors are Creation, Modification, and Deletion.
A script named 'YCOMB_RSTD' has been defined.
No properties or methods have been added.
The page organization is based on 2 sections: HEADER and LINES. Each section contains two blocks called HEADER and LINES.
The properties are:
- In the HEADER block
  - 'YCOMB.YGRP' with the alias 'YGRP'
  - 'YCOMB.YNAM' with the alias 'YNAM'
  Both are present on all the facets and can be entered.
- In the LINES block
  - 'YCOMB.YCOMBD.YSGRP' with the alias 'YGRP'
  - 'YCOMB.YCOMBD.YTEXTE' with the alias 'YTEXTE'
  - 'YCOMB.YCOMD.YSDATE' with the alias 'YDATE'
  - 'YCOMB.YCOMBD.YNUM' with the alias 'YNUM'.
  All are present on the facets Detail and Edit, and can be entered.

The 'YCOMB_CSTD' script

Header	Read method	Insertion method	Update method
Delete method	Subprograms	Events on collection	Events on properties

The script implements the CRUD method for the combined object. The 'YCOMB' class is not persistent; therefore, the AREAD, AINSERT, AUPDATE, and ADELETE events are used. This is located in the script just after the '$METHOD' label in case 'CURPTH' is empty.

Additionally, the following two events: 'AREAD_AFTER' and 'ADDLINE_AFTER' have to be handled on every 'YCOMBD' record. When this happens, 'CURPTH' is equal to 'YCOMBD'.

Header

The beginning of the script is as follows:

CODECODE CODEsh
###############
# METHODS
###############
$METHODS
Case CURPTH
    When ""
        Case ACTION
            When "AREAD"                  : Gosub AREAD
            When "AINSERT"                : Gosub AINSERT
            When "AUPDATE"                : Gosub AUPDATE
            When "ADELETE"                : Gosub ADELETE
        Endcase
    When "YCOMBD"
        Case ACTION
            When "AREAD_AFTER"   : Gosub YCOMBD_AREAD_AFTER
            When "ADDLINE_AFTER" : Gosub YCOMBD_ADDLINE_AFTER
        Endcase
Endcase
Return

Read method

The 'AREAD' method performs a reading loop on the 'YCOMBD' table. For every existing record, the 'ADDLINE' method is invoked on the 'YCOMBD' collection to add a line at the end of the table. Then, The standard 'AREAD' method is used on the line instance to fill the record. The loop process stops if any error is found. This corresponds to the following code:

CODECODE CODEsh
$AREAD
Local File YCOMB [YCO]
Local Integer ILINE

  For [YCO] Where YGRP=this.YGRP
    ILINE = fmet this.ADDLINE("YCOMBD",CST_ALASTPOS)
    [L]ASTATUS = fmet this.YCOMBD(ILINE).AREAD([F:YCO]YGRP,[F:YCO]YSGRP)
    # The syntax Break condition means that if condition is true (ie 1), a Break 1 is done (Break 0 does nothing)
    Break [L]ASTATUS>=[V]CST_AERROR
  Next
Return

Insertion method

Consistency checks must be performed on the insertion method:

At least one line must exist.
No duplicate value of lines is allowed.

The corresponding sub-program is 'CTL_CONSISTENCY'.

A loop is performed to insert all of the lines with 'CST_ANEW' as the line status. While in insertion mode, the only other status that can be encountered is 'CST_ANEWDEL'.

Controlling that 'this.YCOMBD(ILINE)' is not null is useless in this case because the instance collection has been created by only adding lines at the end of the table, and because the deletion done is exclusively logical. The code is as follows:

CODECODE CODEsh
$AINSERT
Local Integer ILINE

# Consistency controls
  Gosub CTL_CONSISTENCY : If [L]ASTATUS>=[V]CST_AERROR : Return : Endif

# Loop on every line that has to be created
  For ILINE=1 To maxtab(this.YCOMBD)
    If this.YCOMBD(ILINE)<>null
      If this.YCOMBD(ILINE).ASTALIN = CST_ANEW
        [L]ASTATUS = fmet this.YCOMBD(ILINE).AINSERT()
        Break ([L]ASTATUS>=[V]CST_AERROR)
      Endif
    Endif
  Next
Return

Update method

The same first control is performed on the update method.

Three loops handle the different modifications that are made on the lines:

The first loop deletes the lines with 'ASTALIN' equal to 'CST_ADEL'.
The second loop updates the lines with 'ASTALIN' equal to 'CST_AUPD'.
The third loop updates the lines with 'ASTALIN' equal to 'CST_ANEW'.

The code is as follows:

CODECODE CODEsh
$AUPDATE
Local Integer ILINE

  Gosub CTL_CONSISTENCY : If [L]ASTATUS>=[V]CST_AERROR : Return : Endif

# Delete the lines
  For ILINE= 1 To maxtab(this.YCOMBD)
    If this.YVOMB(ILINE)<>null
      If this.YCOMBD(ILINE).ASTALIN = [V]CST_ADEL
        [L]ASTATUS = fmet this.YCOMBD(ILINE).ADELETE()
        If [L]ASTATUS>=[V]CST_AERROR : Return : Endif
      Endif
    Endif
  Next

# Update the lines
  For ILINE= 1 To maxtab(this.YCOMBD)
    If this.YCOMBD(ILINE)<>null
      If this.YCOMBD(ILINE).ASTALIN = [V]CST_AUPD
        [L]ASTATUS = fmet this.YCOMB(ILINE).AUPDATE()
        If [L]ASTATUS>=[V]CST_AERROR : Return : Endif
      Endif
    Endif
  Next

# Insert the lines
  For ILINE= 1 To maxtab(this.YCOMBD)
    If this.YCOMBD(ILINE)<>null
      If this.YCOMBD(ILINE).ASTALIN = [V]CST_ANEW
        [L]ASTATUS = fmet this.YCOMBD(ILINE).AINSERT()
        Break [L]ASTATUS>=[V]CST_AERROR
      Endif
    Endif
  Next
Return

Delete method

A loop is initiated on every line that invokes the 'DELETE' method. The loop stops when an error occurs.

The code is as follows:

CODECODE CODEsh
$ADELETE
Local Integer ILINE
  For ILINE= 1 To maxtab(this.YCOMBD)
    If this.YCOMBD(ILINE)<>null
      [L]ASTATUS = fmet this.YCOMBD(ILINE).ADELETE()
      Break [L]ASTATUS>=[V]CST_AERROR
    Endif
  Next
Return

The CTL_CONSISTENCY subprogram

This subprogram performs a loop on the YCOMBD collection. If at least a line is found, LINE_FOUND is set to 1. A second loop, concatenated with the first one, checks whether the same YGRP value has been used on another line. If this is the case, an error is invoked and the loop is stopped.

CODECODE CODEsh
# Check the consistency
$CTL_CONSISTENCY
Local Shortint LINE_FOUND
Local Integer IL, JL

  For IL=1 To maxtab(this.YCOMBD)
    If this.YCOMB(IL)<>null
      If find(this.YCOMB(IL).ASTALIN,[V]CST_ADEL,[V]CST_ANEWDEL)=0
        LINE_FOUND=1
        For JL= IL+1 To maxtab(this.YCOMBD)
          If this.YCOMB(JL)<>null
            If find(this.YCOMB(JL).ASTALIN,[V]CST_ADEL,[V]CST_ANEWDEL)=0
              If this.YCOMB(IL).YSGRP= this.YCOMB(JL).YSGRP
                [L]ASTATUS = fmet this.ASETERROR("YGRP", this.YCOMB(IL).YSGRP -":"-mess(94,139,1),[V]CST_AERROR)
                Break 2
              Endif
            Endif
          Endif
        Next JL
      Endif
    Endif
  Next IL
  If LINE_FOUND=0
    [L]ASTATUS = fmet this.ASETERROR("",mess(178,123,1),[V]CST_AERROR)
  Endif
Return

Events on the 'YCOMB' collection

Two events are necessary to properly manage the collection:

The reading loop adds lines to the grid and assigns on each one the status 'CST_ANEW'. They should be considered as existing lines. For this reason, the assignment of 'ASTALIN' to '[v]CST_ALL' must be done.
Every time a line is added to the grid, it is necessary to apply the header properties on the new line (YGRP and YNAM).

This provides the following code:

CODECODE CODEsh
$YCOMB_AREAD_AFTER
# Assign ASTALIN to CST_ALL (they have the value 'CST_ANEW' just after AREAD method)
this.ASTALIN = [V]CST_ALL
Return

$YCOMB_ADDLINE_AFTER
# To initialize properties of the header
this.YGRP = this.APARENT.YGRP
this.YNAM = this.APARENT.YNAM
Return

Events called on the properties

The following additional controls must be done on the properties (after the '$PROPERTIES' label in the script below):

If the 'YGRP' or 'YNAM' properties are modified on the header, the modification should also apply on the lines.
When a member is added to the group, no duplicate values are allowed in the grid. This control will be done at another level.

This provides the following code:

CODECODE CODEsh
$PROPERTIES
  # If YGRP or YNAM have been modified, perform a loop to update all the lines
  Case CURPRO
    When "YGRP"
      Case ACTION
        When 'PROPAGATE'
          Local Integer IL
          For IL= 1 To maxtab(this.YCOMBD)
            If this.YCOMBD(IL)<>null
              this.YCOMBD(IL).YGRP = this.YGRP
            Endif
          Next IL
      Endcase
    When "YNAM"
      Case ACTION
        When 'PROPAGATE'
          Local Integer IL
          For IL= 1 To maxtab(this.YCOMBD)
            If this.YCOMBD(IL)<>null
              this.YCOMBD(IL).YGRP = this.YGRP
            Endif
          Next IL
      Endcase
  Endcase
Return

The script associated with the 'YCOMB' representation

This script manages the list of codes by using a table in memory. The code is as follows:

CODECODE CODEsh
#########################
# Representation YCOMB
#########################

###############
# METHODS
###############
$METHODS
Case CURPTH
   When ""
     Case ACTION
       When "AQUERY_DECODE_CRITERIA_AFTER" : Gosub AQUERY_DECODE_CRITERIA_AFTER
       When "AQUERY_PRIMARYKEYS_AFTER"     : Gosub AQUERY_PRIMARYKEYS_AFTER
       When "AQUERY_OPEN_AFTER"            : Gosub AQUERY_OPEN_AFTER
       When "AQUERY_TRANS_AFTER"           : Gosub AQUERY_TRANS_AFTER
       When "AQUERY_CLOSE_AFTER"           : Gosub AQUERY_CLOSE_AFTER
     Endcase
Endcase
Return

#################### Standard Query Events #########################

$AQUERY_DECODE_CRITERIA_AFTER
Raz NBPRO
NBPRO += 1
TBPRO(NBPRO) = "YGRP" : TBTYP(NBPRO) = 7 : TBPTH(NBPRO) = "YCOMBH.YGRP" : TBFIL(NBPRO) = "[LNK_]YGRP"
NBPRO += 1
TBPRO(NBPRO) = "YNAM" : TBTYP(NBPRO) = 7 : TBPTH(NBPRO) = "YCOMBH.YNAM" : TBFIL(NBPRO) = "[LNK_]YNAM"
Return

$AQUERY_PRIMARYKEYS_AFTER
ASTDKEY = "[LNK_]YGRP"
Return

$AQUERY_OPEN_AFTER
Local File YCOMB [QRY_YC]
Local Integer I : I=0
Local Char TYGRP(12)(1..), TYNAM(40)(1..)
For [QRY_YC]YCO0(1)
 I+=1
 TYGRP(I) = [F:QRY_YC]YGRP
 TYNAM(I) = [F:QRY_YC]YNAM
Next

# A test must be done on I (this will be fixed later)
# On empty arrays, for behaves as if 32,768 lines were here!
If I<>0
  Local File (Char YGRP(100),Char YNAM(100)) From Variable TYGRP,TYNAM As [LNK_]
Else
  Local File YCOMB [LNK_]
Endif
Return

$AQUERY_TRANS_AFTER
this.YCOMB.YGRP = [LNK_]YGRP
this.YCOMB.YNAM = [LNK_]YNAM
Return

$AQUERY_CLOSE_AFTER
Close Local File [LNK_]
Return

Index Home