/*****************************************************************************
******************************************************************************

f_manifest.js

Written by Chris Harding and Joshua McKinney
© Copyright F1 Solutions Pty Ltd 2003

This file holds the manifest manipulation code for some pages.

Production Version 2.0 - June 2007

******************************************************************************
*****************************************************************************/


/* Function: checkManifestRequirements()                   */
/*                                                         */
/* This function loads all the data into the global arrays */
/* and determines if a manifest is required.               */
/* required.                                               */
/*                                                         */
/* INPUTS : int                                            */
/* OUTPUTS: boolean                                        */

function checkManifestRequirements() {
    blnManifestRequired = false;
    initialiseArrays();
    loadGoodsLocally('checkManifestRequirements');
    loadGoodsIntoPremises();

    //for(cmridx=0; cmridx < numPremises; cmridx++) {
        checkAreaManifesting();
    //}
    return blnManifestRequired;
}



/* Function: checkAreaManifesting()
/* This function checks manifest levels of goods across storage areas
/*
/* INPUTS : int                                            */
/* OUTPUTS: none                                           */
function checkAreaManifesting() {
    var blnAeroPlacard = false;
    var blnCryoPlacard = false;
    var blnC1Isolated = true;
    var intAeroCount = checkForAeros(intPremise);
    var intCryoCount = checkForCryos(intPremise);
    var aManifestTotal = new Array(intAreaTotalFC);
    var intItem6Qty=0;
    var intMixedAmount = 0;

    // 04/03/2005 1.4 CJH
    // not initialising this array causes NaN to be
    // stored, negating the manifest check
    for(var j=0; j < aManifestTotal.length; j++) {
        aManifestTotal[j] = 0;
    }

    for (var intPremise = 0; intPremise < numPremises; intPremise++) {

        /* ITEM 1 */
        aManifestTotal[eATAClass21] += aAreaTotal[intPremise][eATAClass21];
        if (aManifestTotal[eATAClass21] >
                aScheduleManifestLimit[eItem1_Class21]) {
            blnManifestRequired = true;
            break;
        }

        aManifestTotal[eATAClass22Sub51] += aAreaTotal[intPremise][eATAClass22Sub51];
        if (aManifestTotal[eATAClass22Sub51] >
                aScheduleManifestLimit[eItem1_Class22Sub51]) {
            blnManifestRequired = true;
            break;
        }

        aManifestTotal[eATAClass22SubNot51] += aAreaTotal[intPremise][eATAClass22SubNot51];
        if (aManifestTotal[eATAClass22SubNot51] >
                aScheduleManifestLimit[eItem1_Class22Other]) {
            blnManifestRequired = true;
            break;
        }

        aManifestTotal[eATAClass23] += aAreaTotal[intPremise][eATAClass23];
        if (aManifestTotal[eATAClass23] >
                aScheduleManifestLimit[eItem1_Class23]) {
            blnManifestRequired = true;
            break;
        }

        // check total aeros > limit
        aManifestTotal[eATAClassA21] += aAreaTotal[intPremise][eATAClassA21];
        aManifestTotal[eATAClassA22] += aAreaTotal[intPremise][eATAClassA22];
        aManifestTotal[eATAClassA2251] += aAreaTotal[intPremise][eATAClassA2251];
        aManifestTotal[eATAClassA23] += aAreaTotal[intPremise][eATAClassA23];
        if (aManifestTotal[eATAClassA21] +
                aManifestTotal[eATAClassA22] +
                aManifestTotal[eATAClassA2251] +
                aManifestTotal[eATAClassA23] >
                aScheduleManifestLimit[eItem1_Class2A]) {
            blnManifestRequired = true;
            break;
        }

        // check total cryos > limit
        aManifestTotal[eATAClassC21] += aAreaTotal[intPremise][eATAClassC21];
        aManifestTotal[eATAClassC22] += aAreaTotal[intPremise][eATAClassC22];
        aManifestTotal[eATAClassC2251] += aAreaTotal[intPremise][eATAClassC2251];
        aManifestTotal[eATAClassC23] += aAreaTotal[intPremise][eATAClassC23];
        if (aManifestTotal[eATAClassC21] +
                aManifestTotal[eATAClassC22] +
                aManifestTotal[eATAClassC2251] +
                aManifestTotal[eATAClassC23] >
                aScheduleManifestLimit[eItem1_Class2C]) {
            blnManifestRequired = true;
            break;
        }
        /* END ITEM 1 */

        /* ITEM 2 */
        // 3
        aManifestTotal[eATAClass3Pack1] += aAreaTotal[intPremise][eATAClass3Pack1];
        aManifestTotal[eATAClass3Pack2] += aAreaTotal[intPremise][eATAClass3Pack2];
        aManifestTotal[eATAClass3Pack3] += aAreaTotal[intPremise][eATAClass3Pack3];
        if ((aManifestTotal[eATAClass3Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass3Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass3Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass3Pack1] +
                aManifestTotal[eATAClass3Pack2] +
                aManifestTotal[eATAClass3Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 4.1
        aManifestTotal[eATAClass41Pack1] += aAreaTotal[intPremise][eATAClass41Pack1];
        aManifestTotal[eATAClass41Pack2] += aAreaTotal[intPremise][eATAClass41Pack2];
        aManifestTotal[eATAClass41Pack3] += aAreaTotal[intPremise][eATAClass41Pack3];
        if ((aManifestTotal[eATAClass41Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass41Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass41Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass41Pack1] +
                aManifestTotal[eATAClass41Pack2] +
                aManifestTotal[eATAClass41Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 4.2
        aManifestTotal[eATAClass42Pack1] += aAreaTotal[intPremise][eATAClass42Pack1];
        aManifestTotal[eATAClass42Pack2] += aAreaTotal[intPremise][eATAClass42Pack2];
        aManifestTotal[eATAClass42Pack3] += aAreaTotal[intPremise][eATAClass42Pack3];
        if ((aManifestTotal[eATAClass42Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass42Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass42Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass42Pack1] +
                aManifestTotal[eATAClass42Pack2] +
                aManifestTotal[eATAClass42Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 4.3
        aManifestTotal[eATAClass43Pack1] += aAreaTotal[intPremise][eATAClass43Pack1];
        aManifestTotal[eATAClass43Pack2] += aAreaTotal[intPremise][eATAClass43Pack2];
        aManifestTotal[eATAClass43Pack3] += aAreaTotal[intPremise][eATAClass43Pack3];
        if ((aManifestTotal[eATAClass43Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass43Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass43Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass43Pack1] +
                aManifestTotal[eATAClass43Pack2] +
                aManifestTotal[eATAClass43Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 5.1
        aManifestTotal[eATAClass51Pack1] += aAreaTotal[intPremise][eATAClass51Pack1];
        aManifestTotal[eATAClass51Pack2] += aAreaTotal[intPremise][eATAClass51Pack2];
        aManifestTotal[eATAClass51Pack3] += aAreaTotal[intPremise][eATAClass51Pack3];
        if ((aManifestTotal[eATAClass51Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass51Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass51Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass51Pack1] +
                aManifestTotal[eATAClass51Pack2] +
                aManifestTotal[eATAClass51Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 5.2
        aManifestTotal[eATAClass52Pack1] += aAreaTotal[intPremise][eATAClass52Pack1];
        aManifestTotal[eATAClass52Pack2] += aAreaTotal[intPremise][eATAClass52Pack2];
        aManifestTotal[eATAClass52Pack3] += aAreaTotal[intPremise][eATAClass52Pack3];
        if ((aManifestTotal[eATAClass52Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass52Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass52Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass52Pack1] +
                aManifestTotal[eATAClass52Pack2] +
                aManifestTotal[eATAClass52Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 6.1
        aManifestTotal[eATAClass61Pack1] += aAreaTotal[intPremise][eATAClass61Pack1];
        aManifestTotal[eATAClass61Pack2] += aAreaTotal[intPremise][eATAClass61Pack2];
        aManifestTotal[eATAClass61Pack3] += aAreaTotal[intPremise][eATAClass61Pack3];
        if ((aManifestTotal[eATAClass61Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass61Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass61Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass61Pack1] +
                aManifestTotal[eATAClass61Pack2] +
                aManifestTotal[eATAClass61Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }

        // 8
        aManifestTotal[eATAClass8Pack1] += aAreaTotal[intPremise][eATAClass8Pack1];
        aManifestTotal[eATAClass8Pack2] += aAreaTotal[intPremise][eATAClass8Pack2];
        aManifestTotal[eATAClass8Pack3] += aAreaTotal[intPremise][eATAClass8Pack3];
        if ((aManifestTotal[eATAClass8Pack1] > aScheduleManifestLimit[eItem2_Pack1]) ||
                (aManifestTotal[eATAClass8Pack2] > aScheduleManifestLimit[eItem2_Pack2]) ||
                (aManifestTotal[eATAClass8Pack3] > aScheduleManifestLimit[eItem2_Pack3]) ||
                ((aManifestTotal[eATAClass8Pack1] +
                aManifestTotal[eATAClass8Pack2] +
                aManifestTotal[eATAClass8Pack3]) >
                aScheduleManifestLimit[eItem2_PackM])) {
            blnManifestRequired = true;
            break;
        }
        /* END ITEM 2 */

        /* ITEM 3 */
        // 9
        aManifestTotal[eATAClass9Pack2] += aAreaTotal[intPremise][eATAClass9Pack2];
        aManifestTotal[eATAClass9Pack3] += aAreaTotal[intPremise][eATAClass9Pack3];
        if ((aManifestTotal[eATAClass9Pack2] > aScheduleManifestLimit[eItem3_Pack2]) ||
                (aManifestTotal[eATAClass9Pack3] > aScheduleManifestLimit[eItem3_Pack3]) ||
                ((aManifestTotal[eATAClass9Pack2] +
                aManifestTotal[eATAClass9Pack3]) >
                aScheduleManifestLimit[eItem3_PackM])) {
            blnManifestRequired = true;
            break;
        }
        /* END ITEM 3 */

        /* Item 6 */
        // GTDTT
        aManifestTotal[eATAGTDTT] += aAreaTotal[intPremise][eATAGTDTT];
        if (aManifestTotal[eATAGTDTT] > aScheduleManifestLimit[eItem6]) {
            blnManifestRequired = true;
            break;
        }
        /* END Item 6 */

        /* Item 5 */
        // C1s, C2s and any FireRisks
        var blnHasCombustibleLiquids = ((
				aAreaTotal[intPremise][eATAC1Bulk] +
                aAreaTotal[intPremise][eATAC1BulkNotIsolated] +
                aAreaTotal[intPremise][eATAC1Packaged] +
                aAreaTotal[intPremise][eATAC1PackagedNotIsolated] +
                aAreaTotal[intPremise][eATAC2Bulk] +
                aAreaTotal[intPremise][eATAC2Packaged]) > 0);

        if (aAreaTotal[intPremise][eATAHasFireRisk] && blnHasCombustibleLiquids) {
            if (aGrandTotal.length>0) {
                for (intAA=0; intAA<numGoods; intAA++) {
                    if (aGrandTotal[intAA][eGTAStorageArea]==intPremise) {
                        if ((aGrandTotal[intAA][eGTAClass]==C1) || (aGrandTotal[intAA][eGTAClass]==C2) || (aGrandTotal[intAA][eGTAIsFireRisk]==true))
                            intItem6Qty += aGrandTotal[intAA][eGTAQuantity];
                        }
                }
            }
            if (intItem6Qty > aScheduleManifestLimit[eItem5]) {
                blnManifestRequired = true;
            break;
            }
        }
        /* END Item 5 */

        /* ITEM 7 */
        // C1
        aManifestTotal[eATAC1Bulk] += aAreaTotal[intPremise][eATAC1Bulk];
        aManifestTotal[eATAC1BulkNotIsolated] += aAreaTotal[intPremise][eATAC1BulkNotIsolated];
        aManifestTotal[eATAC1Packaged] += aAreaTotal[intPremise][eATAC1Packaged];
        aManifestTotal[eATAC1PackagedNotIsolated] += aAreaTotal[intPremise][eATAC1PackagedNotIsolated];
        if ( (aManifestTotal[eATAC1Bulk] > aScheduleManifestLimit[eItem7_Bulk]) ||
        	 (aManifestTotal[eATAC1BulkNotIsolated] > aScheduleManifestLimit[eItem7_Bulk]) ||
             (aManifestTotal[eATAC1Packaged] > aScheduleManifestLimit[eItem7_Pack]) ||
             (aManifestTotal[eATAC1PackagedNotIsolated] > aScheduleManifestLimit[eItem7_Pack]) ||
             ( ( aManifestTotal[eATAC1Bulk] + aManifestTotal[eATAC1BulkNotIsolated] +
                 aManifestTotal[eATAC1Packaged] + aManifestTotal[eATAC1PackagedNotIsolated]
               ) > aScheduleManifestLimit[eItem7_BulkPack])
           ) {
            blnManifestRequired = true;
            break;
        }
        /* END ITEM 7 */

        /* ITEM 4 */
        intMixedAmount += aAreaTotal[intPremise][eATAClass21];
        intMixedAmount += aAreaTotal[intPremise][eATAClass22Sub51];
        intMixedAmount += aAreaTotal[intPremise][eATAClass22SubNot51];
        intMixedAmount += aAreaTotal[intPremise][eATAClass23];

        // aeros
        intMixedAmount += aAreaTotal[intPremise][eATAClassA21];
        intMixedAmount += aAreaTotal[intPremise][eATAClassA22];
        intMixedAmount += aAreaTotal[intPremise][eATAClassA2251];
        intMixedAmount += aAreaTotal[intPremise][eATAClassA23];
        // cryos
        intMixedAmount += aAreaTotal[intPremise][eATAClassC21];
        intMixedAmount += aAreaTotal[intPremise][eATAClassC22];
        intMixedAmount += aAreaTotal[intPremise][eATAClassC2251];
        intMixedAmount += aAreaTotal[intPremise][eATAClassC23];

        intMixedAmount += aAreaTotal[intPremise][eATAClass3Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass3Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass3Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass41Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass41Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass41Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass42Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass42Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass42Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass43Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass43Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass43Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass51Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass51Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass51Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass52Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass52Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass52Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass61Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass61Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass61Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass8Pack1];
        intMixedAmount += aAreaTotal[intPremise][eATAClass8Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass8Pack3];

        intMixedAmount += aAreaTotal[intPremise][eATAClass9Pack2];
        intMixedAmount += aAreaTotal[intPremise][eATAClass9Pack3];
        if (intMixedAmount > aScheduleManifestLimit[eItem4a]) {
            blnManifestRequired = true;
            break;
        }
        /* END ITEM 4 */
    } // end for each premises
}



var aDangerousGoods;
var aCombustibleLiquids;
var aTooDangerous;


/****************************************************************************/
/* Function: initialiseManifestReportArrays()
/*
/* This function aggregates the quantites of every class except bulk, 2.3s
/* and PG Is. The arrays used are the ones from the f_placard.js file
/*
/* INPUTS : none
/* OUTPUTS: none
/****************************************************************************/
function initialiseManifestReportArrays() {
    aDangerousGoods = new Array();
    aCombustibleLiquids = new Array();
    aTooDangerous = new Array();

    if(aGrandTotal.length>0) {
        for(var iGT = 0; iGT < aGrandTotal.length ; iGT++) {
            // if bulk, 2.3 or PGI then dont aggregate on Class and PG
            if(aGrandTotal[iGT][eGTAStorageType] == ePacking_Bulk ||
                    aGrandTotal[iGT][eGTAClass] == Class_2_3 ||
                    aGrandTotal[iGT][eGTAPackingGroup] == packingGroup_I) {
                switch(aGrandTotal[iGT][eGTAClass]) {
                    case GoodsTooDangerous:
                        aTooDangerous[aTooDangerous.length] = aGrandTotal[iGT];
                        break;
                    case C1:
                    case C2:
                        aCombustibleLiquids[aCombustibleLiquids.length] = aGrandTotal[iGT];
                        break;
                    default:
                        aDangerousGoods[aDangerousGoods.length] = aGrandTotal[iGT];
                        break;
                }
            } else {
                // not bulk, 2.3 nor PG I so aggregate goods
                switch(aGrandTotal[iGT][eGTAClass]) {
                    case GoodsTooDangerous:
                        aggregateQuantity(aTooDangerous, aGrandTotal[iGT]);
                        break;
                    case C1:
                    case C2:
                        aggregateQuantity(aCombustibleLiquids, aGrandTotal[iGT]);
                        break;
                    default:
                        aggregateQuantity(aDangerousGoods, aGrandTotal[iGT]);
                        break;
                }
            }
        }
    }
    // sort aggregate arrays by Class then Packing Group
    aTooDangerous.sort(compareGoods_SA_ST_Cl_PG);
    aCombustibleLiquids.sort(compareGoods_SA_ST_Cl_PG);
    aDangerousGoods.sort(compareGoods_SA_ST_Cl_PG);
}
/****************************************************************************/
/* End Function: initialiseManifestReportArrays()
/****************************************************************************/


/****************************************************************************/
/* Function: compareGoods_SA_ST_Cl_PG(a, b)
/*
/* This function compares two goods and returns an integer based on the order
/* that they should be sorted in.
/* First sorted by storage area.
/* Second sorted by storage type.
/* Third sorted by class.
/* Forth sorted by packing group.
/*
/* Returns a negative integer if a comes before b.  Returns a positive integer
/* if b comes before a.  Returns 0 neither comes first.
/*
/* INPUTS: good, good
/* OUTPUTS: int
/****************************************************************************/
function compareGoods_SA_ST_Cl_PG(a, b) {
    var as = a[eGTAStorageArea];
    var bs = b[eGTAStorageArea];
    var ast = a[eGTAStorageType];
    var bst = b[eGTAStorageType];
    var ac = getClassA(a[eGTAClass]);
    var bc = getClassA(b[eGTAClass]);

    if (as < bs) {
        return -1;
    }
    if (bs < as) {
        return 1;
    }
    if (ast < bst) {
        return -1;
    }
    if (bst < ast) {
        return 1;
    }
    if (ac < bc) {
        return -1;
    }
    if (bc < ac) {
        return 1;
    }
    return (a[eGTAPackingGroup] - b[eGTAPackingGroup]);
}
/****************************************************************************/
/* End Function: compareGoods_SA_ST_Cl_PG(a, b)
/****************************************************************************/


/****************************************************************************/
/* Function: aggregateQuantity(pArray, pRow)
/*
/* This function aggregates the data from pRow into pArray. If matching data
/* is found, the quantities are added. Otherwise a new array index is created.
/*
/* INPUTS : array, grandtotalarray row
/* OUTPUTS: none
/****************************************************************************/
function aggregateQuantity(pArray, pRow) {
    var blnFound = false;
    var theArray = pArray;
    for(var iA=0; iA<theArray.length; iA++) {
        if(theArray[iA][eGTAClass] == pRow[eGTAClass] &&
                theArray[iA][eGTAPackingGroup] == pRow[eGTAPackingGroup] &&
                theArray[iA][eGTAStorageType] == pRow[eGTAStorageType] &&
                theArray[iA][eGTAStorageArea] == pRow[eGTAStorageArea]) {
            // found existing row, add to it
            theArray[iA][eGTAQuantity] += pRow[eGTAQuantity];
            blnFound = true;
            break;
        }
    }
    if(!blnFound) {
        // create new row in pArray
        addGoodToAggregateArray(pArray, pRow)
    }
}
/****************************************************************************/
/* End Function: aggregateQuantity(pArray, pRow)
/****************************************************************************/


/****************************************************************************/
/* Function: addGoodToAggregateArray(pArray, pRow)
/*
/* This function adds the good in pRow into pArray. It creates a new row or
/* aggregates depending on class, bulk and packing group.
/*
/* INPUTS : array, grandtotalarray row
/* OUTPUTS: none
/****************************************************************************/
function addGoodToAggregateArray(pArray, pRow) {
    var theArray = pArray;
    var theRow = pRow;
    var theLength = theArray.length;
    theArray[theLength] = new Array(intGrandTotalFC);
    // data that is only needed for bulk, 2.3 or PG1 goods
    if(theRow[eGTAStorageType]==ePacking_Bulk ||
            theRow[eGTAClass]==Class_2_3 ||
            theRow[eGTAPackingGroup]==packingGroup_I) {
        theArray[theLength][eGTAName] = pRow[eGTAName];
        theArray[theLength][eGTAUN] = pRow[eGTAUN];
        theArray[theLength][eGTAShippingName] = pRow[eGTAShippingName];
        theArray[theLength][eGTASubrisk1] = pRow[eGTASubrisk1];
        theArray[theLength][eGTASubrisk2] = pRow[eGTASubrisk2];
        theArray[theLength][eGTACapacity] = pRow[eGTACapacity];
        theArray[theLength][eGTAContainerID] = pRow[eGTAContainerID];
        theArray[theLength][eGTAHazchem] = pRow[eGTAHazchem];
    } else {
        theArray[theLength][eGTAName] = "[Aggregate]";
        theArray[theLength][eGTAUN] = "N/A";
        theArray[theLength][eGTAShippingName] = "[Aggregate]";
        theArray[theLength][eGTASubrisk1] = ClassNA;
        theArray[theLength][eGTASubrisk2] = ClassNA;
        theArray[theLength][eGTACapacity] = 0;
        theArray[theLength][eGTAContainerID] = "N/A";
        theArray[theLength][eGTAHazchem] = "N/A";
    }
    // data that is always collected
    theArray[theLength][eGTAStorageType] = pRow[eGTAStorageType];
    theArray[theLength][eGTAClass] = pRow[eGTAClass];
    theArray[theLength][eGTAIsFireRisk] = pRow[eGTAIsFireRisk];
    theArray[theLength][eGTAPackingGroup] = pRow[eGTAPackingGroup];
    theArray[theLength][eGTAStorageArea] = pRow[eGTAStorageArea];
    theArray[theLength][eGTAQuantity] = pRow[eGTAQuantity];
    theArray[theLength][eGTAC1Isolated] = pRow[eGTAC1Isolated];
    theArray[theLength][eGTAExempt] = pRow[eGTAExempt];
}
/****************************************************************************/
/* End Function: addGoodToAggregateArray(pArray, pRow)
/****************************************************************************/