Managing CRUD Combined Objects

Introduction

A combined object is made of a unique table containing a key with two components. This table has multiple records that are associated with a given value of the first key component.

In this mode:

• The header includes the first component of the key, as well as 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 object is not automated, objects can be created using the supervisor.

Table description

Table "YCOMB [YCO]" has the following structure (technical columns are not listed):

"YCO0" is the unique key of the table. It has no duplicates and it is made of two components: YGRP+YSGRP.

Main principles

• The CRUD methods are defined in the table. A class called "YCOMBD" was created for this purpose. Any business rule associated with updating the table is defined with no direct attached representation.
• An interface class named "YCOMB" and its representation were created to manage the user interface. They run:
  • The query based on a list of the first key component.
  • A collection of "YCOMBD" instances, each instance being a line attached to a given header value.
• The AREAD, AINSERT, AUPDATE, and ADELETE methods in the interface class invoke the CRUD methods of the "YCOMBD" class within a loop that runs through all the records.

"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, Read, Update, 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 it. However, you can add one if necessary.

"YCOMB" class definition

This class has the following characteristics:

• It is interface-typed, with a key named "YGRP".
• A collection named "YCOMBD" was declared with the following characteristics:
  • Minimum=0 and Maximum=0
  • Insertion, Deletion, Sorting, and Addition check boxes selected.
• A script named "YCOMB_CSTD" was 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 in the header.
  • "YCOMBD", which is an instance of the "YCOMBD" collection, is part of this collection.

"YCOMB" representation

This representation has the following characteristics:

• It is associated with the "YCOMB" class, with "YCOMB" as an instance name.
• Managed behaviors are Creation, Modification, and Deletion.
• A script named "YCOMB_RSTD" was defined.
• No properties or methods were added.
• The page organization is based on two 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 can be found on all 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 can be found on facets Detail and Edit, and can be entered.

  
  

"YCOMB_CSTD" script

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. They are located in the script, right after the $METHOD label in case "CURPTH" is empty.

Additionally, 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:

sh################ METHODS###############$METHODSCase CURPTHWhen ""Case ACTIONWhen "AREAD" : Gosub AREADWhen "AINSERT": Gosub AINSERTWhen "AUPDATE": Gosub AUPDATEWhen "ADELETE": Gosub ADELETEEndcaseWhen "YCOMBD"Case ACTIONWhen "AREAD_AFTER" : Gosub YCOMBD_AREAD_AFTERWhen "ADDLINE_AFTER" : Gosub YCOMBD_ADDLINE_AFTEREndcaseEndcaseReturn

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. The standard AREAD method is then used on the line instance to fill the record. The loop process stops if any error is found. This corresponds to the following code:

sh$AREADLocal File YCOMB [YCO]Local Integer ILINEFor [YCO] Where YGRP=this.YGRPILINE = 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_AERRORNextReturn

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".

In this case, there is no need to make sure this.YCOMBD(ILINE) is not null because the instance collection was created by only adding lines at the end of the table, and because the deletion is exclusively logical.

The code is as follows:

sh$AINSERTLocal Integer ILINE# Consistency controlsGosub CTL_CONSISTENCY : If [L]ASTATUS>=[V]CST_AERROR : Return : Endif# Loop on every line that has to be createdFor ILINE=1 To maxtab(this.YCOMBD)If this.YCOMBD(ILINE)<>nullIf this.YCOMBD(ILINE).ASTALIN = CST_ANEW[L]ASTATUS = fmet this.YCOMBD(ILINE).AINSERT()Break ([L]ASTATUS>=[V]CST_AERROR)EndifEndifNextReturn

Update method

The same initial 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 where "ASTALIN" equals "CST_ADEL".
• The second loop updates the lines where "ASTALIN" equals "CST_AUPD".
• The third loop updates the lines where "ASTALIN" equals "CST_ANEW".

The code is as follows:

sh$AUPDATELocal Integer ILINEGosub CTL_CONSISTENCY : If [L]ASTATUS>=[V]CST_AERROR : Return : Endif# Delete the linesFor ILINE= 1 To maxtab(this.YCOMBD)If this.YVOMB(ILINE)<>nullIf this.YCOMBD(ILINE).ASTALIN = [V]CST_ADEL[L]ASTATUS = fmet this.YCOMBD(ILINE).ADELETE()If [L]ASTATUS>=[V]CST_AERROR : Return : EndifEndifEndifNext# Update the linesFor ILINE= 1 To maxtab(this.YCOMBD)If this.YCOMBD(ILINE)<>nullIf this.YCOMBD(ILINE).ASTALIN = [V]CST_AUPD[L]ASTATUS = fmet this.YCOMB(ILINE).AUPDATE()If [L]ASTATUS>=[V]CST_AERROR : Return : EndifEndifEndifNext# Insert the linesFor ILINE= 1 To maxtab(this.YCOMBD)If this.YCOMBD(ILINE)<>nullIf this.YCOMBD(ILINE).ASTALIN = [V]CST_ANEW[L]ASTATUS = fmet this.YCOMBD(ILINE).AINSERT()Break [L]ASTATUS>=[V]CST_AERROREndifEndifNextReturn

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:

sh$ADELETELocal Integer ILINEFor ILINE= 1 To maxtab(this.YCOMBD)If this.YCOMBD(ILINE)<>null[L]ASTATUS = fmet this.YCOMBD(ILINE).ADELETE()Break [L]ASTATUS>=[V]CST_AERROREndifNextReturn

"CTL_CONSISTENCY" subprogram

This subprogram performs a loop on the "YCOMBD" collection. If at least one 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.

The code is as follows:

sh# Check the consistency$CTL_CONSISTENCYLocal Shortint LINE_FOUNDLocal Integer IL, JLFor IL=1 To maxtab(this.YCOMBD)If this.YCOMB(IL)<>nullIf find(this.YCOMB(IL).ASTALIN,[V]CST_ADEL,[V]CST_ANEWDEL)=0LINE_FOUND=1For JL= IL+1 To maxtab(this.YCOMBD)If this.YCOMB(JL)<>nullIf find(this.YCOMB(JL).ASTALIN,[V]CST_ADEL,[V]CST_ANEWDEL)=0If 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 2EndifEndifEndifNext JLEndifEndifNext ILIf LINE_FOUND=0[L]ASTATUS = fmet this.ASETERROR("",mess(178,123,1),[V]CST_AERROR)EndifReturn

Events on the "YCOMB" collection

Two events are necessary to properly manage the collection:

• The reading loop adds lines to the grid and assigns the "CST_ANEW" status to each of them. They should be considered as existing lines. For this reason, "ASTALIN" has to be assigned to "[v]CST_ALL".
• 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:

sh$YCOMB_AREAD_AFTER# Assign ASTALIN to CST_ALL (they have the value 'CST_ANEW' just after AREAD method)this.ASTALIN = [V]CST_ALLReturn$YCOMB_ADDLINE_AFTER# To initialize properties of the headerthis.YGRP = this.APARENT.YGRPthis.YNAM = this.APARENT.YNAMReturn

Events called on the properties

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

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

This provides the following code:

sh$PROPERTIES# If YGRP or YNAM have been modified, perform a loop to update all the linesCase CURPROWhen "YGRP"Case ACTIONWhen 'PROPAGATE'Local Integer ILFor IL= 1 To maxtab(this.YCOMBD)If this.YCOMBD(IL)<>nullthis.YCOMBD(IL).YGRP = this.YGRPEndifNext ILEndcaseWhen "YNAM"Case ACTIONWhen 'PROPAGATE'Local Integer ILFor IL= 1 To maxtab(this.YCOMBD)If this.YCOMBD(IL)<>nullthis.YCOMBD(IL).YGRP = this.YGRPEndifNext ILEndcaseEndcaseReturn

Script associated with the "YCOMB" representation

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

sh########################## Representation YCOMB######################################### METHODS###############$METHODSCase CURPTHWhen ""Case ACTIONWhen "AQUERY_DECODE_CRITERIA_AFTER" : Gosub AQUERY_DECODE_CRITERIA_AFTERWhen "AQUERY_PRIMARYKEYS_AFTER" : Gosub AQUERY_PRIMARYKEYS_AFTERWhen "AQUERY_OPEN_AFTER" : Gosub AQUERY_OPEN_AFTERWhen "AQUERY_TRANS_AFTER" : Gosub AQUERY_TRANS_AFTERWhen "AQUERY_CLOSE_AFTER" : Gosub AQUERY_CLOSE_AFTEREndcaseEndcaseReturn#################### Standard Query Events #########################$AQUERY_DECODE_CRITERIA_AFTERRaz NBPRONBPRO += 1TBPRO(NBPRO) = "YGRP" : TBTYP(NBPRO) = 7 : TBPTH(NBPRO) = "YCOMBH.YGRP" : TBFIL(NBPRO) = "[LNK_]YGRP"NBPRO += 1TBPRO(NBPRO) = "YNAM" : TBTYP(NBPRO) = 7 : TBPTH(NBPRO) = "YCOMBH.YNAM" : TBFIL(NBPRO) = "[LNK_]YNAM"Return$AQUERY_PRIMARYKEYS_AFTERASTDKEY = "[LNK_]YGRP"Return$AQUERY_OPEN_AFTERLocal File YCOMB [QRY_YC]Local Integer I : I=0Local Char TYGRP(12)(1..), TYNAM(40)(1..)For [QRY_YC]YCO0(1)I+=1TYGRP(I) = [F:QRY_YC]YGRPTYNAM(I) = [F:QRY_YC]YNAMNext# 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<>0Local File (Char YGRP(100),Char YNAM(100)) From Variable TYGRP,TYNAM As [LNK_]ElseLocal File YCOMB [LNK_]EndifReturn$AQUERY_TRANS_AFTERthis.YCOMB.YGRP = [LNK_]YGRPthis.YCOMB.YNAM = [LNK_]YNAMReturn$AQUERY_CLOSE_AFTERClose Local File [LNK_]Return