<cfsilent>
<!---  THE CONTAINS THE LOGIC FOR APPLY_CONING
-----  THE LOGIC CONTAINED WITHIN THIS FILE, IS INCLUDED IN THE FILE, APPLY_CONING.cfm---->

<cfset VARIABLES.unique_id = CreateUUID()>
<cfset VARIABLES.finClassUtil = server.javaLoader.create("com.powerhealth.pbrcae.fin.FinancialClassUtil").init()>

<cfif isDefined('arguments.sb_invoice_id')>
    <cfquery name="Check_Disable_Costing" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        SELECT ISNULL(invoice_type.SB_DISABLE_COSTING, 'N') AS SB_DISABLE_COSTING
        FROM SB_INVOICE invoice
            INNER JOIN SB_INVOICE_TYPE invoice_type ON invoice_type.SB_INVOICE_TYPE_CODE =  invoice.SB_INVOICE_TYPE_CODE
            AND invoice_type.SB_CURRENT = 'Y'
        WHERE invoice.SB_INVOICE_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#arguments.sb_invoice_id#">
    </cfquery>

    <cfif Check_Disable_Costing.SB_DISABLE_COSTING eq "Y">
        <!--- Recheck potential Errors --->
        <cfinvoke component="allocate_chart_of_acc" method="allocate" returnvariable="none">
            <cfinvokeargument name="alloc_coac_mrn" value="#ARGUMENTS.mrn#">
            <cfinvokeargument name="alloc_coac_hl7_source" value="#ARGUMENTS.source#">
            <cfinvokeargument name="imaging_install" value="0">
            <cfinvokeargument name="alloc_coac_invoice_id" value="#arguments.sb_invoice_id#">
        </cfinvoke>
        <cfreturn>
    </cfif>

<cfelse>
    <cfquery name="Invoices" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        SELECT ISNULL(invoice_type.SB_DISABLE_COSTING, 'N') AS SB_DISABLE_COSTING, SB_INVOICE_ID
        FROM SB_INVOICE invoice
            left outer JOIN SB_INVOICE_TYPE invoice_type ON invoice_type.SB_INVOICE_TYPE_CODE =  invoice.SB_INVOICE_TYPE_CODE
            AND invoice_type.SB_CURRENT = 'Y'
        WHERE invoice.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
            AND invoice.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
    </cfquery>

    <cfscript>

        invoiceList = server.javaLoader.create("com.powerhealth.pbrcae.util.StringListBuilder").init(",");

    </cfscript>

        <cfloop query="Invoices">
            <cfif SB_DISABLE_COSTING neq 'Y'>
                <cfscript>
                    invoice = "";
                    invoice = SB_INVOICE_ID;
                    invoiceList.append("" & invoice & "");
                </cfscript>
            </cfif>
        </cfloop>

    <cfset arguments.sb_invoice_id = invoiceList.toString()>

</cfif>

<!---
Check to see if emergency dept compensable invoices can be raised on the same day as an inpatient episode.
If so, SDCOM parameter will be set to 'Y' --->
<cfscript>
    same_day_compensable = application.cache.getSysParam("SDCOM");
</cfscript>

<!--- >> CACHED_QUERY << Find the (or a) 100% mbs item cost table.
Used as a back-up price if price not defined for health fund no gaps --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="MBS100" returnvariable="MBS100">
<cfif MBS100.SB_COST_TYPE_ID EQ "">
    <cfset session.errormsg = "The system administrator must set up which cost type is MBS 100%">
    <cflocation url="../sber01.cfm" addtoken="No">
</cfif>

<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="NO_SPECIALIST" returnvariable="NO_SPECIALIST">
<cfset item_types_not_requiring_specialist = "">
<cfoutput query="NO_SPECIALIST">
    <cfset item_types_not_requiring_specialist
         = item_types_not_requiring_specialist & NO_SPECIALIST.SB_ITEM_TYPE_CODE & ",">
</cfoutput>

<!--- Check if any records about to be coned have an item_status of 'ER' - Error.
If they do, and the error has been resolved, then the item status is not reset.
To avoid this, run allocate_bill_mech against any invoices with 'ER'.
Mostly CF_allocate_bill_mech is called before apply_coning, but I suspect there
are times when it is skipped.
 --->
<cfif IsDefined("ARGUMENTS.call_allocate_bill_mech") and ARGUMENTS.call_allocate_bill_mech eq "N">
<!---   Do not call allocate bill mech if called from sbbp34 --->
<cfelse>
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Errorcheck">
        SELECT
            DISTINCT SB_INVOICE.SB_INVOICE_ID, SB_DISABLE_COSTING
        FROM
            SB_INVOICE_ITEM
                INNER JOIN
            SB_INVOICE  ON SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID
                INNER JOIN
            SB_INVOICE_TYPE ON SB_INVOICE.SB_INVOICE_TYPE_CODE = SB_INVOICE_TYPE.SB_INVOICE_TYPE_CODE
            WHERE   (   SB_INVOICE_ITEM.SB_ITEM_STATUS_CODE = 'ER'
                     or (SB_INVOICE.SB_INVOICE_DATE IS NULL AND SB_INVOICE_ITEM.SB_ITEM_STATUS_CODE in ('03','1C')))
              and   SB_INVOICE_ITEM.sb_voucher_id is null
              and   SB_INVOICE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
              and   SB_INVOICE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
    </cfquery>

    <cfoutput query="Errorcheck">
        <!--- Set appropriate billing mechanism, invoice status and invoice item status.
            No processing it done is invoice has a date. --->
        <cfinvoke component="allocate_bill_mech"
        method="allocate"
        returnvariable="none">
        <cfif SB_DISABLE_COSTING eq 'Y'>
            <cfinvokeargument name="apply_bill_mech" value="N">
        </cfif>

        <cfinvokeargument name="sb_invoice_id" value="#Errorcheck.SB_INVOICE_ID#">
        </cfinvoke>

    </cfoutput>
</cfif>

<cfif arguments.sb_invoice_id eq ''>
        <cfreturn>
</cfif>

<!---
Phil : 11-Jan-2008

When Medicare updated their end to Eclipse 6, the field previously used for number of fields in DVA rad onc claims vaporized.
Up until then, Rad Onc claims were sent as a base item, with another item specifying the number of fields. Payment for the two items was paid against one item only.
An adjustment process (SBBP46) swapped the payments around.

Post Eclipse 6 at medicare (with p2 on eclipse 4), in order to send multiple fields through to DVA, the field item needs to be repeated multiple times.
When payment is returned, only one of the items gets the full payment.
To further complicate matters, the amount paid by DVA on the fields is "Derived", but it does not publish how the figure is derived. It appears to be a straight payment per field.
Rather than use the coning rules, it is easier just to define the cost for the item.

apply_coning splits DVA online items with multiple fields to be multiple items with one field in each.
Sets SB_MIGRATION_P1_ITEM_ID to be the item id of the original item.

sbbp46 spreads payment of items with the same SB_MIGRATION_P1_ITEM_ID value.
 --->


    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="PharmacyErrorCheck">
        SELECT
            DISTINCT
            SB_INVOICE.SB_INVOICE_ID,
            SB_DEBTOR.SB_DEBTOR_ADDRESS_1,
            SB_DEBTOR.SB_DEBTOR_SUBURB,
            SB_DEBTOR.SB_DEBTOR_POSTCODE
        FROM
            SB_INVOICE_ITEM     INNER JOIN
            SB_INVOICE  ON
                    SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID INNER JOIN
            SB_DEBTOR  ON
                SB_INVOICE.SB_DEBTOR_ID = SB_DEBTOR.SB_DEBTOR_ID
            WHERE
                (SB_INVOICE.SB_INVOICE_DATE IS NULL
                 OR SB_INVOICE_ITEM.SB_ITEM_STATUS_CODE in ('03','1C'))
              AND   SB_INVOICE_ITEM.SB_ITEM_STATUS_CODE < '50'
              and   SB_INVOICE_ITEM.sb_claim_id is null
              and   SB_INVOICE_ITEM.sb_voucher_id is null
              and   SB_INVOICE.SB_BILL_MECH_CODE = 'P'
              and   SB_INVOICE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
              and   SB_INVOICE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
              and   SB_INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
    </cfquery>




 <!---
 Populate table SB_CONING_RUN with invoices that do not have an invoice date
 for the selected MRN and HL7 Source

Similar code exists in allocate_bill_mech
  --->
 <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="INSERT_CONING_RECORDS">
    SET DATEFORMAT DMY
    INSERT INTO SB_CONING_RUN
    (
        SB_CONING_RUN_NO,
        SB_ITEM_NUMBER,
        SB_SCHEDULE_FEE,
        SB_ACTUAL_FEE,
        SB_DERIVED_NOGAP_PERCENT,
        SB_CONING_STATUS_CODE,
        SB_SERVICE_DATE,
        SB_CONING_ITEM_ID,
        SB_ACTUAL_FEE_75,
        SB_MBS_100_COST,
        SB_CONING_PROVIDER,
        SB_CONING_PATIENT_AGE,
        SB_CONING_MSG_TO_HIC,
        SB_CONING_QTY,
        SB_GST_PERCENT,
        SB_APPLY_CONING,
        SB_CONING_SPECIALTY_CODE,
        SB_CONING_HOSP_CODE,
        SB_CONING_FIN_CLASS,
        SB_CONING_BILL_MECH,
        SB_CONING_EPISODE,
        SB_REQUEST_DATE,
        SB_CONING_ITEM_TYPE,
        SB_CONING_REQUEST_PROVIDER,
        SB_CONING_NOT_DUP_SERVICE,
        SB_CONING_MULTIPLE_OVERRIDE,
        SB_CONING_REQUIREMENT_CODE,
        SB_CONING_ADMIT_DATE,
        SB_CONING_DISCH_DATE,
        SB_CONING_INVOICE_ID,
        SB_CONING_REQ_PROV_START,
        SB_CONING_REQ_PROV_END,
        SB_CONING_FIN_CLASS_VALID,
        SB_CONING_HOSP_VALID,
        SB_CONING_SPEC_PROV_DEFINED,
        SB_SERV_PROV_VALID,
        SB_CONING_LSPN,
        SB_CONING_FUND_GROUP_ID,
        SB_CONING_REFERRAL_OVERRIDE,
        SB_CONING_DURATION,
        SB_PRIV_BILLING_END_DATE,
        SB_CONING_FIN_CLASS_TYPE_CODE,
        SB_CONING_DEFENCE,
        CURRENT_DEDUCTIONS
    )
    SELECT
        /* THIS CF VARIABLE CONTAINS A GUID */
        '#VARIABLES.unique_id#',
        MBS_ITEM.SB_MBS_ITEM_NUMBER,
        /* INSERT A ZERO SO THE CONING ERROR DOESN'T APPEAR WHEN PROSTHESIS ITEMS ARE USED THAT DO NOT HAVE A PRICE.*/
        CASE WHEN MBS_ITEM.SB_ITEM_TYPE_CODE <> 'R' THEN
            ITEM_COST.SB_MBS_ITEM_FEE
        ELSE
            ISNULL(ITEM_COST.SB_MBS_ITEM_FEE, 0)
        END AS SB_MBS_ITEM_FEE,
 /* if price entered, then use it.
    if price defined in table, then use it
    if nogap, and price not in fund table, use mbs cost */
        CASE WHEN  ITEM.SB_PRICE_OVERRIDE = 'Y' --AND ITEM_COST.SB_MBS_ITEM_FEE IS NULL
                        THEN
                            CASE WHEN ITEM.SB_GST_AMOUNT_CLAIMED IS NOT NULL
                                THEN ITEM.SB_INVOICE_COST - ITEM.SB_GST_AMOUNT_CLAIMED
                                ELSE ITEM.SB_INVOICE_COST
                            END
            WHEN  ISNULL(ITEM.SB_PRICE_OVERRIDE, 'N') = 'N' AND ITEM_COST.SB_MBS_ITEM_FEE IS NOT NULL and ITEM_COST.SB_ITEM_QTY IS NULL
                        THEN ITEM_COST.SB_MBS_ITEM_FEE * ITEM.SB_ITEM_QTY
            WHEN  ISNULL(ITEM.SB_PRICE_OVERRIDE, 'N') = 'N' AND ITEM_COST.SB_MBS_ITEM_FEE IS NOT NULL and ITEM_COST.SB_ITEM_QTY IS NOT NULL
                        THEN ITEM_COST.SB_MBS_ITEM_FEE
             WHEN ITEM_COST.SB_MBS_ITEM_FEE IS NOT NULL AND ITEM_COST.SB_MBS_ITEM_FEE > 0
                        THEN ITEM_COST.SB_MBS_ITEM_FEE
             WHEN HEALTH_FUND.SB_FUND_NO_GAPS = 'Y'
              AND SCHEME.SB_FUND_PROVIDER_ID IS NOT NULL
              AND   ((SB_SERVICE_DATE BETWEEN COVERAGE.SB_NOGAP_START_DATE AND ISNULL(COVERAGE.SB_NOGAP_END_DATE, GETDATE()) ) OR EPISODE.SB_COVERAGE_ID IS NULL)
                        THEN DEFAULT_ITEM_COST.SB_MBS_ITEM_FEE
              ELSE 0
        END,
        ITEM_COST.SB_DERIVED_NOGAP_PERCENT,
        MECH.SB_INITIAL_ITEM_STATUS,
        ITEM.SB_SERVICE_DATE,
        ITEM.SB_INVOICE_ITEM_ID,
        ITEM_COST.SB_MBS_ITEM_FEE_75,
        DEFAULT_ITEM_COST.SB_MBS_ITEM_FEE,
        INVOICE.SB_PROVIDER_NUMBER,
        abs(Case when datepart(dy, PATIENT_REGISTER.SB_PATIENT_DOB) > datepart(dy, ITEM.SB_SERVICE_DATE)
            then year(ITEM.SB_SERVICE_DATE) - year(PATIENT_REGISTER.SB_PATIENT_DOB) - 1
            else year(ITEM.SB_SERVICE_DATE) - year(PATIENT_REGISTER.SB_PATIENT_DOB)
        end),
        '',
        ITEM.SB_ITEM_QTY,
        GST.SB_GST_PERCENT,
        CRITERIA.SB_APPLY_CONING_RULES,
        INVOICE.SB_SPECIALTY_CODE,
        EPISODE.SB_HOSPITAL_CODE,
        EFC.SB_FIN_CLASS_CODE,
-- Pharmacy is not represented in cost_type_criteria as Pharmacy episodes do not have any episode fin class records.
        Case
        when EPISODE.SB_EPISODE_TYPE_CODE = 'P'
             then 'P'
        WHEN Invoice.SB_BILL_MECH_CODE = 'B' AND EPISODE.SB_MC_FORM_SIGNED = 'Y' AND SB_MEDICARE_IMAGE_FILENAME IS NOT NULL THEN
            'B'
        ELSE
            IsNull(Invoice.SB_RERAISE_BILL_MECH, CRITERIA.SB_BILL_MECH_CODE)
        end,
        EPISODE.SB_EPISODE_NUMBER,
        ITEM.SB_REQUEST_DATE,
        MBS_ITEM.SB_ITEM_TYPE_CODE,
        ITEM.SB_PROVIDER_NUMBER,
        IsNull(ITEM.SB_HICOL_NOT_DUP_SERVICE,'N'),
        IsNull(ITEM.SB_MULTIPLE_PROCEDURE_OVERRIDE,'N'),
        CASE WHEN ITEM.SB_INV_ITEM_COMMENT LIKE 'Split by Pbrc-ae for Eclipse 4%' THEN '' ELSE IsNull(ITEM.SB_REQUIREMENT_CODE,'N/A') END,
        EPISODE.SB_ADMISSION_DATE,
        EPISODE.SB_DISCHARGE_DATE,
        INVOICE.SB_INVOICE_ID,
        IsNull(REQUESTING_PROVIDER.SB_PROVIDER_START_DATE,'31-dec-1900') AS SB_PROVIDER_START_DATE,
        IsNull(REQUESTING_PROVIDER.SB_PROVIDER_END_DATE,'31-dec-3000') AS SB_PROVIDER_END_DATE,
        CASE WHEN (FIN_CLASS.SB_FIN_CLASS_DESC = 'Undefined Fin Class' or FIN_CLASS.SB_FIN_CURRENT <> 'Y')
             THEN 'N'
             WHEN FIN_CLASS_TYPE.SB_COMPENSABLE = 'Y'
             THEN 'C'
             ELSE 'Y'
        END,
        CASE WHEN HOSPITAL.SB_HOSPITAL_NAME = 'Unknown' or HOSPITAL.SB_HOSPITAL_CURRENT <> 'Y'
             THEN 'N'
             ELSE 'Y'
        END,
        CASE WHEN SB_DR_SPECIALTY.sb_specialty_code IS NULL
            THEN 'N'
            ELSE 'Y'
        END,
        CASE WHEN PROVIDER.SB_PROVIDER_SURNAME = 'Unknown'
            THEN 'N'
            ELSE 'Y'
        END,
        IsNull(SB_DR_SPECIALTY.SB_LSPN, HOSPITAL.SB_LSPN) AS SB_LSPN,
        CRITERIA.SB_FUND_GROUP_ID,
        Case when item.SB_HICOL_SELF_DEEMED = 'D' then 'D'
             else ITEM.SB_REFERRAL_OVERRIDE
        End,
        ITEM.SB_DURATION,
        SB_ROOM_MODALITY_MAPPING.SB_PRIVATE_BILLING_END_DATE,
        FIN_CLASS_TYPE.SB_FIN_CLASS_TYPE_CODE,
        FIN_CLASS_TYPE.SB_DEFENSE,
        0
    FROM
        SB_PATIENT_EPISODE EPISODE   INNER JOIN
        SB_PATIENT_REGISTER PATIENT_REGISTER  ON
                EPISODE.SB_PATIENT_MRN = PATIENT_REGISTER.SB_PATIENT_MRN AND
                EPISODE.SB_HL7_SOURCE = PATIENT_REGISTER.SB_HL7_SOURCE INNER JOIN
        SB_INVOICE INVOICE  ON
            EPISODE.SB_EPISODE_NUMBER = INVOICE.SB_EPISODE_NUMBER INNER JOIN
        SB_INVOICE_ITEM ITEM  ON
            INVOICE.SB_INVOICE_ID = ITEM.SB_INVOICE_ID INNER JOIN
        SB_GST_CATEGORY GST with (nolock) ON
            ITEM.SB_GST_CAT_ID = GST.SB_GST_CAT_ID  INNER JOIN
        SB_MBS_ITEM MBS_ITEM  with (nolock) ON
            ITEM.SB_MBS_ITEM_NUMBER = MBS_ITEM.SB_MBS_ITEM_NUMBER INNER JOIN
        SB_ITEM_TYPE ITEM_TYPE with (nolock) ON
            MBS_ITEM.SB_ITEM_TYPE_CODE = ITEM_TYPE.SB_ITEM_TYPE_CODE INNER JOIN
        /* SELECT THE FINANCNIAL CLASS WHERE THE SERVICE DATE IS BETWEEN THE EPISODE FIN CLASS */
    SB_EPISODE_FIN_CLASS EFC   ON
        EPISODE.SB_EPISODE_NUMBER = EFC.SB_EPISODE_NUMBER AND
        (
        CONVERT(DATETIME, CONVERT(VARCHAR, ITEM.SB_SERVICE_DATE, 103)) = EFC.SB_FIN_DATE  OR
            (
            MBS_ITEM.SB_ITEM_TYPE_CODE = 'T' AND
            CONVERT(DATETIME, CONVERT(VARCHAR, EPISODE.SB_DISCHARGE_DATE, 103)) = EFC.SB_FIN_DATE
            )
            OR
            (
                EPISODE.SB_EPISODE_TYPE_CODE = 'P'
            )
        )
        INNER JOIN
        SB_FINANCIAL_CLASSIFICATION FIN_CLASS with (nolock) ON
            EFC.SB_FIN_CLASS_CODE = FIN_CLASS.SB_FIN_CLASS_CODE INNER JOIN
        SB_HOSPITAL HOSPITAL  with (nolock) ON
            EPISODE.SB_HOSPITAL_CODE = HOSPITAL.SB_HOSPITAL_CODE
        LEFT OUTER JOIN
        SB_HEALTH_FUND HEALTH_FUND with (nolock) ON
            EPISODE.SB_HEALTH_FUND_CODE = HEALTH_FUND.SB_HEALTH_FUND_CODE  LEFT OUTER JOIN
        SB_PROVIDER REQUESTING_PROVIDER with (nolock) ON
            REQUESTING_PROVIDER.SB_PROVIDER_NUMBER = ITEM.SB_PROVIDER_NUMBER    LEFT OUTER JOIN
        SB_DR_SPECIALTY with (nolock) ON
                SB_DR_SPECIALTY.sb_specialty_code = INVOICE.sb_specialty_code AND
                SB_DR_SPECIALTY.sb_provider_number = INVOICE.sb_provider_number LEFT OUTER JOIN
        SB_PROVIDER PROVIDER with (nolock) ON
            INVOICE.SB_PROVIDER_NUMBER = PROVIDER.SB_PROVIDER_NUMBER LEFT OUTER JOIN
        SB_FUND_PROVIDER_SCHEME SCHEME with (nolock) ON
            INVOICE.SB_PROVIDER_NUMBER = SCHEME.SB_PROVIDER_NUMBER AND
            EPISODE.SB_HEALTH_FUND_CODE = SCHEME.SB_HEALTH_FUND_CODE AND
            ITEM.SB_SERVICE_DATE BETWEEN SCHEME.SB_FUND_PROVIDER_START_DATE AND ISNULL(SCHEME.SB_FUND_PROVIDER_END_DATE, GETDATE())
        LEFT OUTER JOIN
        SB_HEALTH_FUND_COVERAGE COVERAGE with (nolock) ON
            EPISODE.SB_COVERAGE_ID = COVERAGE.SB_COVERAGE_ID AND
            COVERAGE.SB_NOGAP_START_DATE  <= (SELECT MIN(SB_SERVICE_DATE) FROM SB_INVOICE_ITEM WHERE SB_INVOICE_ID = INVOICE.SB_INVOICE_ID)  AND
            ( COVERAGE.SB_NOGAP_END_DATE IS NULL OR COVERAGE.SB_NOGAP_END_DATE >= (SELECT MAX(SB_SERVICE_DATE) FROM SB_INVOICE_ITEM WHERE SB_INVOICE_ID = INVOICE.SB_INVOICE_ID))
        LEFT OUTER JOIN
        SB_COST_TYPE_CRITERIA CRITERIA with (nolock) ON
            CRITERIA.SB_COST_TYPE_CRITERIA_ID = INVOICE.SB_COST_TYPE_CRITERIA_ID
            LEFT OUTER JOIN
        /* SELECT THE ITEM'S COST WHERE THE SERVICE DATE IS BEWTEEN THE COST START AND END DATE */
        SB_MBS_ITEM_COST ITEM_COST  with (nolock) ON
            MBS_ITEM.SB_MBS_ITEM_NUMBER = ITEM_COST.SB_MBS_ITEM_NUMBER AND
            CRITERIA.SB_COST_TYPE_ID = ITEM_COST.SB_COST_TYPE_ID AND
            ITEM.SB_SERVICE_DATE BETWEEN ITEM_COST.SB_MBS_COST_START AND ISNULL(ITEM_COST.SB_MBS_COST_END,'31-DEC-3100') AND
-- item qty used only for rad onc items. On other item cost records it is null.
            (ITEM_COST.SB_ITEM_QTY IS NULL OR ITEM.SB_ITEM_QTY = ITEM_COST.SB_ITEM_QTY)
            LEFT OUTER JOIN
        /* SELECT THE DEFAULT MBS ITEM COST IN CASE FUND NO GAP PRICE IS MISSING */
        SB_MBS_ITEM_COST DEFAULT_ITEM_COST with (nolock) ON
            MBS_ITEM.SB_MBS_ITEM_NUMBER = DEFAULT_ITEM_COST.SB_MBS_ITEM_NUMBER AND
            DEFAULT_ITEM_COST.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# AND
            ITEM.SB_SERVICE_DATE BETWEEN DEFAULT_ITEM_COST.SB_MBS_COST_START AND ISNULL(DEFAULT_ITEM_COST.SB_MBS_COST_END,'31-DEC-3100')
            LEFT OUTER JOIN
        SB_FIN_CLASS_TYPE FIN_CLASS_TYPE  with (nolock) ON
            FIN_CLASS.SB_FIN_CLASS_TYPE_CODE = FIN_CLASS_TYPE.SB_FIN_CLASS_TYPE_CODE LEFT OUTER JOIN
        SB_BILLING_MECHANISM MECH  with (nolock) ON
            IsNull(Invoice.SB_RERAISE_BILL_MECH, CRITERIA.SB_BILL_MECH_CODE) = MECH.SB_BILL_MECH_CODE
        LEFT OUTER JOIN SB_INV_BATCH
            ON SB_INV_BATCH.SB_INV_BATCH_ID = ITEM.SB_INV_BATCH_ID
        LEFT OUTER JOIN SB_ROOM_MODALITY_MAPPING
            ON ITEM.SB_RMM_ID = SB_ROOM_MODALITY_MAPPING.SB_RMM_ID
-- If an invoice has been reraised, it will have an RT flag. It should therefore be ignored in any coning checks etc.
        LEFT OUTER JOIN SB_INVOICE_ERROR
            ON INVOICE.SB_INVOICE_ID = SB_INVOICE_ERROR.SB_INVOICE_ID
            AND SB_INVOICE_ERROR.SB_INVOICE_FLAG_CODE = 'RT'
        WHERE
            SB_INVOICE_ERROR.SB_INVOICE_FLAG_CODE IS NULL AND
<!--- If allocate bill mech set the status to 'ER, then don't check further.
This was added by Phil to prevent overwriting (and clearing) of error code and text
if it was set by allocate_bill_mech.
 --->
            SB_EPISODE_DELETION_DATE IS NULL AND
            ITEM.SB_ITEM_STATUS_CODE <> 'ER' AND
            ITEM.SB_ITEM_STATUS_CODE <> 'MI' AND  -- Items migrated to another system should be ignored.
            (SB_INV_BATCH.SB_BATCH_STATUS IS NULL OR SB_INV_BATCH.SB_BATCH_STATUS <> 'C') AND
            (INVOICE.SB_INVOICE_DATE IS NULL
             OR ITEM.SB_ITEM_STATUS_CODE in ('03','1C'))
            AND ITEM.SB_ITEM_STATUS_CODE < '50'
            and ITEM.sb_claim_id is null
            and ITEM.sb_voucher_id is null
            AND
            EPISODE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#"> and
            EPISODE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
<!--- The db4 clinic is for printing db4 certificates only. No invoices will ever be processed from this pseudo clinic --->
             and (episode.sb_clinic_code is null or episode.sb_clinic_code <> 'DB4')
<!--- Only Cone internal invoices - ignore externally generated invoices. --->
            and (INVOICE.SB_SOURCE_CODE = 'I')
            and INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
        ORDER BY
            EPISODE.SB_PATIENT_MRN,
            ITEM.SB_SERVICE_DATE,
            ITEM.SB_MBS_ITEM_NUMBER
 </cfquery>


<!--- Tidy coning - the matching to cost type criteria on health fund
should be "If Fund group matches and no gaps select record,
           else if criteria fund is null select record"
However, this code does not work as desired, in that if the fund does match, the 'else'
match also is selected. Hence a clean up afterwards to delete these duplications. --->

<!--- If there are two records for the same invoice item, and one has a null cost, then delete it --->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_Dup1">
    SELECT  SB_CONING_ITEM_ID,
            SB_CONING_ID,
            IsNull(SB_SCHEDULE_FEE,-1) as SB_SCHEDULE_FEE
    FROM    SB_CONING_RUN
    WHERE   SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
    ORDER BY SB_CONING_ITEM_ID, SB_SCHEDULE_FEE DESC, SB_CONING_FUND_GROUP_ID desc
</cfquery>
<cfset last_item = "">

<cfoutput query="Find_Dup1">
    <cfif last_item neq Find_Dup1.SB_CONING_ITEM_ID>
        <cfset last_item = Find_Dup1.SB_CONING_ITEM_ID>
    <cfelse>
        <cfif Find_Dup1.SB_SCHEDULE_FEE EQ -1>
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Kill_Dup1">
                DELETE FROM SB_CONING_RUN
                WHERE   SB_CONING_ID = #Find_Dup1.SB_CONING_ID#
            </cfquery>
        </cfif>
    </cfif>
</cfoutput>

<!--- If there are still two records for the same invoice item,
it should be caused by one having a null fund group. Delete any duplicates,
but give survival preference to a record with a valid fund group. --->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_Dup2">
    SELECT  SB_CONING_ITEM_ID,
            SB_CONING_ID,
            IsNull(SB_CONING_FUND_GROUP_ID,'') as SB_CONING_FUND_GROUP_ID
    FROM    SB_CONING_RUN
    WHERE   SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
    ORDER BY SB_CONING_ITEM_ID, SB_CONING_FUND_GROUP_ID desc
</cfquery>
<cfset last_item = "">

<cfoutput query="Find_Dup2">
    <cfif last_item neq Find_Dup2.SB_CONING_ITEM_ID>
        <cfset last_item = Find_Dup2.SB_CONING_ITEM_ID>
    <cfelse>
        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Kill_Dup2">
            DELETE FROM SB_CONING_RUN
            WHERE   SB_CONING_ID = #Find_Dup2.SB_CONING_ID#
        </cfquery>
    </cfif>
</cfoutput>

<!---
    Process records that do not require coning
 --->
<!--- Find any records that do not have a cost and update the coning_record with an error message --->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MISSING_COST">
    SELECT  CR.SB_CONING_ID,
            CR.SB_CONING_ITEM_ID,
            CR.SB_CONING_FIN_CLASS,
            CR.SB_ITEM_NUMBER,
            CR.SB_ACTUAL_FEE,
            CTC.SB_COST_TYPE_ID,
            CR.SB_CONING_SPECIALTY_CODE,
            CR.SB_CONING_PROVIDER,
            CR.SB_CONING_INVOICE_ID,
            E.SB_EPISODE_TYPE_CODE,
            I.SB_EPISODE_NUMBER,
            II.SB_INV_BATCH_ID
    FROM    SB_CONING_RUN CR
            INNER JOIN SB_PATIENT_EPISODE E with (nolock) ON E.SB_EPISODE_NUMBER = CR.SB_CONING_EPISODE
            INNER JOIN SB_INVOICE_ITEM II with (nolock) ON II.SB_INVOICE_ITEM_ID = CR.SB_CONING_ITEM_ID
            INNER JOIN SB_INVOICE I with (nolock) ON I.SB_INVOICE_ID = II.SB_INVOICE_ID
            INNER JOIN SB_COST_TYPE_CRITERIA CTC with (nolock) ON CTC.SB_COST_TYPE_CRITERIA_ID = I.SB_COST_TYPE_CRITERIA_ID
    WHERE   (CR.SB_SCHEDULE_FEE IS NULL OR CR.SB_SCHEDULE_FEE = 0.00)
            AND SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
</cfquery>


<cfif MISSING_COST.RECORDCOUNT NEQ 0>
    <cfset ORG_MISSING_COST_LIST_CONING_ID = VALUELIST(MISSING_COST.SB_CONING_ID)>
    <!--- Perform item cost determination and item number transformation based on the COST_DEFAULT_MAPPING table --->
    <cfoutput query="MISSING_COST">
        <!--- Retrieves alternate costs by looking up the Cost Type Default;
            Considers the costs based on the alternate Item Number (SB_ALTERNATE_ITEM_CODE/ALT_MIC),
            as well as costs based on the original Item Number (SB_MBS_ITEM_NUMBER/DEF_ALT_MIC)
            Orders by the Cost Type Default priority and only considers non-zero costs. --->
        <cfquery name="ALTERNATE_ITEM_FEE" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
            DECLARE @ITEM_NUMBER  VARCHAR(10)   = <cfif MISSING_COST.SB_ITEM_NUMBER neq "">'#MISSING_COST.SB_ITEM_NUMBER#'<cfelse>NULL</cfif>
            DECLARE @ITEM_ID NUMERIC(18,0)      = <cfif MISSING_COST.SB_CONING_ITEM_ID neq "">'#MISSING_COST.SB_CONING_ITEM_ID#'<cfelse>NULL</cfif>
            DECLARE @FIN_CLASS VARCHAR(8)       = <cfif MISSING_COST.SB_CONING_FIN_CLASS neq "">'#MISSING_COST.SB_CONING_FIN_CLASS#'<cfelse>NULL</cfif>
            DECLARE @EPISODE_TYPE VARCHAR(1)    = <cfif MISSING_COST.SB_EPISODE_TYPE_CODE neq "">'#MISSING_COST.SB_EPISODE_TYPE_CODE#'<cfelse>NULL</cfif>
            DECLARE @ACTUAL_FEE NUMERIC(18,2)   = <cfif MISSING_COST.SB_ACTUAL_FEE neq "">'#MISSING_COST.SB_ACTUAL_FEE#'<cfelse>NULL</cfif>;

            WITH ORIGINAL AS (
                SELECT
                    MIC.SB_COST_TYPE_ID,
                    MIC.SB_MBS_ITEM_NUMBER,
                    MIC.SB_MBS_ITEM_FEE,
                    MIC.SB_MBS_COST_START,
                    MIC.SB_MBS_ITEM_FEE_75,
                    CDM.SB_DEFAULT_COST_TYPE_ID,
                    CDM.SB_PRIORITY,
                    MIC.SB_DERIVED_NOGAP_PERCENT,
                    II.SB_PRICE_OVERRIDE,
                    II.SB_ITEM_QTY,
                    II.SB_SERVICE_DATE,
                    EPISODE.SB_COVERAGE_ID,
                    CTC.SB_FIN_CLASS_TYPE_CODE,
                    CASE WHEN HEALTH_FUND.SB_FUND_NO_GAPS = 'Y' AND SCHEME.SB_FUND_PROVIDER_ID IS NOT NULL
                            AND ((II.SB_SERVICE_DATE BETWEEN COVERAGE.SB_NOGAP_START_DATE AND ISNULL(COVERAGE.SB_NOGAP_END_DATE, GETDATE()) ) OR COVERAGE.SB_COVERAGE_ID IS NULL)
                    THEN 1 ELSE 0 END AS SCHEMEPROVIDER_NO_GAPS
                FROM SB_INVOICE_ITEM II
                INNER JOIN SB_INVOICE INV with (nolock) ON II.SB_INVOICE_ID = INV.SB_INVOICE_ID
                INNER JOIN SB_PATIENT_EPISODE EPISODE with (nolock) ON EPISODE.SB_EPISODE_NUMBER = INV.SB_EPISODE_NUMBER
                INNER JOIN SB_MBS_ITEM_COST MIC with (nolock) ON MIC.SB_MBS_ITEM_NUMBER = II.SB_MBS_ITEM_NUMBER
                    AND II.SB_SERVICE_DATE BETWEEN MIC.SB_MBS_COST_START AND ISNULL(MIC.SB_MBS_COST_END, DATEADD(Y,100,GETDATE()))
                INNER JOIN SB_COST_DEFAULT_MAPPING CDM with (nolock) ON CDM.SB_COST_TYPE_ID = MIC.SB_COST_TYPE_ID
                LEFT OUTER JOIN SB_HEALTH_FUND HEALTH_FUND with (nolock) ON EPISODE.SB_HEALTH_FUND_CODE = HEALTH_FUND.SB_HEALTH_FUND_CODE
                LEFT OUTER JOIN SB_FUND_PROVIDER_SCHEME SCHEME with (nolock) ON INV.SB_PROVIDER_NUMBER = SCHEME.SB_PROVIDER_NUMBER
                    AND EPISODE.SB_HEALTH_FUND_CODE = SCHEME.SB_HEALTH_FUND_CODE
                    AND II.SB_SERVICE_DATE BETWEEN SCHEME.SB_FUND_PROVIDER_START_DATE AND ISNULL(SCHEME.SB_FUND_PROVIDER_END_DATE, GETDATE())
                LEFT OUTER JOIN SB_HEALTH_FUND_COVERAGE COVERAGE with (nolock) ON EPISODE.SB_COVERAGE_ID = COVERAGE.SB_COVERAGE_ID
                    AND COVERAGE.SB_NOGAP_START_DATE <= (SELECT MIN(MIN_II.SB_SERVICE_DATE) FROM SB_INVOICE_ITEM MIN_II WHERE MIN_II.SB_INVOICE_ID = INV.SB_INVOICE_ID)  AND
                        ( COVERAGE.SB_NOGAP_END_DATE IS NULL OR COVERAGE.SB_NOGAP_END_DATE >= (SELECT MAX(MAX_II.SB_SERVICE_DATE) FROM SB_INVOICE_ITEM MAX_II WHERE MAX_II.SB_INVOICE_ID = INV.SB_INVOICE_ID))
                LEFT OUTER JOIN SB_COST_TYPE_CRITERIA CTC with (nolock) ON CTC.SB_COST_TYPE_ID = MIC.SB_COST_TYPE_ID
                WHERE II.SB_INVOICE_ITEM_ID = @ITEM_ID
                    AND CDM.SB_FIN_CLASS_CODE = @FIN_CLASS
                    AND CDM.SB_EPISODE_TYPE_CODE = @EPISODE_TYPE

            ) SELECT TOP 1
                    SB_PRIORITY,
                    SB_COST_TYPE_ID,
                    SB_MBS_ITEM_NUMBER,
                    SB_SCHEDULE_FEE,
                    SB_ACTUAL_FEE,
                    SB_ACTUAL_FEE_75,
                    SB_ITEM_TYPE_CODE,
                    SB_FIN_CLASS_TYPE_CODE,
                    ITEM_VIEW_ID,
                    SB_MBS_COST_START,
                    SB_APPLY_CONING_RULES,
                    SB_DERIVED_NOGAP_PERCENT
                FROM ( SELECT
                    <!--- ORIGINAL ITEM FEE--->
                    ORIGINAL.SB_PRIORITY,
                    ORIGINAL.SB_COST_TYPE_ID,
                    ORIGINAL.SB_MBS_ITEM_NUMBER,
                    CASE WHEN CTC.SB_ITEM_TYPE_CODE <> 'R' THEN ORIGINAL.SB_MBS_ITEM_FEE ELSE ISNULL(ORIGINAL.SB_MBS_ITEM_FEE, 0) END AS SB_SCHEDULE_FEE,
                    CASE
                        WHEN ORIGINAL.SB_PRICE_OVERRIDE = 'Y' AND @ACTUAL_FEE IS NOT NULL
                            THEN @ACTUAL_FEE
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND ORIGINAL.SB_MBS_ITEM_FEE IS NOT NULL and ORIGINAL.SB_ITEM_QTY IS NULL
                            THEN ORIGINAL.SB_MBS_ITEM_FEE * ORIGINAL.SB_ITEM_QTY
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND ORIGINAL.SB_MBS_ITEM_FEE IS NOT NULL and ORIGINAL.SB_ITEM_QTY IS NOT NULL
                            THEN ORIGINAL.SB_MBS_ITEM_FEE
                        WHEN ORIGINAL.SB_MBS_ITEM_FEE IS NOT NULL AND ORIGINAL.SB_MBS_ITEM_FEE > 0
                            THEN ORIGINAL.SB_MBS_ITEM_FEE
                        WHEN ORIGINAL.SCHEMEPROVIDER_NO_GAPS = 1
                            THEN ORIG_DEFAULT_ITEM_COST.SB_MBS_ITEM_FEE
                        ELSE 0 END AS SB_ACTUAL_FEE,
                    ORIGINAL.SB_MBS_ITEM_FEE_75 AS SB_ACTUAL_FEE_75,
                    CTC.SB_ITEM_TYPE_CODE,
                    CTC.SB_FIN_CLASS_TYPE_CODE,
                    ITYPE.ITEM_VIEW_ID,
                    ORIGINAL.SB_MBS_COST_START,
                    CTC.SB_APPLY_CONING_RULES,
                    ORIGINAL.SB_DERIVED_NOGAP_PERCENT AS SB_DERIVED_NOGAP_PERCENT
                FROM ORIGINAL
                LEFT OUTER JOIN SB_COST_TYPE_CRITERIA CTC with (nolock) ON CTC.SB_COST_TYPE_ID = ORIGINAL.SB_COST_TYPE_ID
                LEFT OUTER JOIN SB_ITEM_TYPE ITYPE with (nolock) ON CTC.SB_ITEM_TYPE_CODE = ITYPE.SB_ITEM_TYPE_CODE
                LEFT OUTER JOIN SB_MBS_ITEM_COST ORIG_DEFAULT_ITEM_COST with (nolock)
                    ON  ORIGINAL.SB_MBS_ITEM_NUMBER = ORIG_DEFAULT_ITEM_COST.SB_MBS_ITEM_NUMBER
                    AND ORIG_DEFAULT_ITEM_COST.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID#
                    AND ORIGINAL.SB_SERVICE_DATE BETWEEN ORIG_DEFAULT_ITEM_COST.SB_MBS_COST_START AND ISNULL(ORIG_DEFAULT_ITEM_COST.SB_MBS_COST_END,'31-DEC-3100')
                WHERE ISNULL(ORIGINAL.SB_MBS_ITEM_FEE,0) > 0
                UNION ALL
                SELECT
                    <!--- ALTERNATE ITEM FEE--->
                    ORIGINAL.SB_PRIORITY,
                    ALT_MIC.SB_COST_TYPE_ID,
                    ALT_MIC.SB_MBS_ITEM_NUMBER,
                    CASE WHEN ALT_CTC.SB_ITEM_TYPE_CODE <> 'R' THEN ALT_MIC.SB_MBS_ITEM_FEE ELSE ISNULL(ALT_MIC.SB_MBS_ITEM_FEE, 0) END AS SB_SCHEDULE_FEE,
                    CASE
                        WHEN ORIGINAL.SB_PRICE_OVERRIDE = 'Y' AND @ACTUAL_FEE IS NOT NULL
                            THEN @ACTUAL_FEE
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL and ALT_MIC.SB_ITEM_QTY IS NULL
                            THEN ALT_MIC.SB_MBS_ITEM_FEE * ORIGINAL.SB_ITEM_QTY
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL and ALT_MIC.SB_ITEM_QTY IS NOT NULL
                            THEN ALT_MIC.SB_MBS_ITEM_FEE
                        WHEN ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL AND ALT_MIC.SB_MBS_ITEM_FEE > 0
                            THEN ALT_MIC.SB_MBS_ITEM_FEE
                        WHEN ORIGINAL.SCHEMEPROVIDER_NO_GAPS = 1
                            THEN ALT_DEFAULT_ITEM_COST.SB_MBS_ITEM_FEE
                        ELSE 0 END AS SB_ACTUAL_FEE,
                    ALT_MIC.SB_MBS_ITEM_FEE_75 AS SB_ACTUAL_FEE_75,
                    ALT_CTC.SB_ITEM_TYPE_CODE,
                    ALT_CTC.SB_FIN_CLASS_TYPE_CODE,
                    ALT_ITYPE.ITEM_VIEW_ID,
                    ALT_MIC.SB_MBS_COST_START,
                    ALT_CTC.SB_APPLY_CONING_RULES,
                    ALT_MIC.SB_DERIVED_NOGAP_PERCENT AS SB_DERIVED_NOGAP_PERCENT
                FROM ORIGINAL
                INNER JOIN SB_MBS_ITEM ALTERNATE_CODE with (nolock) ON ALTERNATE_CODE.SB_ALTERNATE_ITEM_CODE = @ITEM_NUMBER
                INNER JOIN  SB_MBS_ITEM_COST ALT_MIC with (nolock) ON ALT_MIC.SB_MBS_ITEM_NUMBER = ALTERNATE_CODE.SB_MBS_ITEM_NUMBER
                    AND ORIGINAL.SB_DEFAULT_COST_TYPE_ID = ALT_MIC.SB_COST_TYPE_ID
                    AND ORIGINAL.SB_SERVICE_DATE BETWEEN ALT_MIC.SB_MBS_COST_START AND ISNULL(ALT_MIC.SB_MBS_COST_END, DATEADD(Y,100,GETDATE()))
                INNER JOIN SB_COST_TYPE_CRITERIA ALT_CTC with (nolock) ON ALT_CTC.SB_COST_TYPE_ID = ALT_MIC.SB_COST_TYPE_ID
                INNER JOIN SB_ITEM_TYPE ALT_ITYPE with (nolock) ON ALT_CTC.SB_ITEM_TYPE_CODE = ALT_ITYPE.SB_ITEM_TYPE_CODE
                LEFT OUTER JOIN SB_MBS_ITEM_COST ALT_DEFAULT_ITEM_COST with (nolock)
                    ON  ALT_DEFAULT_ITEM_COST.SB_MBS_ITEM_NUMBER = ALT_MIC.SB_MBS_ITEM_NUMBER
                    AND ALT_DEFAULT_ITEM_COST.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID#
                    AND ORIGINAL.SB_SERVICE_DATE BETWEEN ALT_DEFAULT_ITEM_COST.SB_MBS_COST_START AND ISNULL(ALT_DEFAULT_ITEM_COST.SB_MBS_COST_END,'31-DEC-3100')
                WHERE ALT_CTC.SB_FIN_CLASS_TYPE_CODE = ORIGINAL.SB_FIN_CLASS_TYPE_CODE
                    AND ISNULL(ALT_MIC.SB_MBS_ITEM_FEE,0) > 0
                UNION ALL
                SELECT
                    <!--- DEFAULT ALTERNATE ITEM FEE--->
                    ORIGINAL.SB_PRIORITY,
                    DEF_ALT_MIC.SB_COST_TYPE_ID,
                    DEF_ALT_MIC.SB_MBS_ITEM_NUMBER,
                    CASE WHEN DEF_ALT_CTC.SB_ITEM_TYPE_CODE <> 'R' THEN DEF_ALT_MIC.SB_MBS_ITEM_FEE ELSE ISNULL(DEF_ALT_MIC.SB_MBS_ITEM_FEE, 0) END AS SB_SCHEDULE_FEE,
                    CASE
                        WHEN ORIGINAL.SB_PRICE_OVERRIDE = 'Y' AND @ACTUAL_FEE IS NOT NULL
                            THEN @ACTUAL_FEE
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND DEF_ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL and DEF_ALT_MIC.SB_ITEM_QTY IS NULL
                            THEN DEF_ALT_MIC.SB_MBS_ITEM_FEE * ORIGINAL.SB_ITEM_QTY
                        WHEN  ISNULL(ORIGINAL.SB_PRICE_OVERRIDE, 'N') = 'N' AND DEF_ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL and DEF_ALT_MIC.SB_ITEM_QTY IS NOT NULL
                            THEN DEF_ALT_MIC.SB_MBS_ITEM_FEE
                        WHEN DEF_ALT_MIC.SB_MBS_ITEM_FEE IS NOT NULL AND DEF_ALT_MIC.SB_MBS_ITEM_FEE > 0
                            THEN DEF_ALT_MIC.SB_MBS_ITEM_FEE
                        WHEN ORIGINAL.SCHEMEPROVIDER_NO_GAPS = 1
                            THEN ALT_DEFAULT_ITEM_COST2.SB_MBS_ITEM_FEE
                        ELSE 0 END AS SB_ACTUAL_FEE,
                    DEF_ALT_MIC.SB_MBS_ITEM_FEE_75 AS SB_ACTUAL_FEE_75,
                    DEF_ALT_CTC.SB_ITEM_TYPE_CODE,
                    DEF_ALT_CTC.SB_FIN_CLASS_TYPE_CODE,
                    DEF_ALT_ITYPE.ITEM_VIEW_ID,
                    DEF_ALT_MIC.SB_MBS_COST_START,
                    DEF_ALT_CTC.SB_APPLY_CONING_RULES,
                    DEF_ALT_MIC.SB_DERIVED_NOGAP_PERCENT AS SB_DERIVED_NOGAP_PERCENT
                FROM ORIGINAL
                INNER JOIN SB_MBS_ITEM_COST DEF_ALT_MIC with (nolock) ON DEF_ALT_MIC.SB_MBS_ITEM_NUMBER = ORIGINAL.SB_MBS_ITEM_NUMBER
                    AND ORIGINAL.SB_DEFAULT_COST_TYPE_ID = DEF_ALT_MIC.SB_COST_TYPE_ID
                    AND ORIGINAL.SB_SERVICE_DATE BETWEEN DEF_ALT_MIC.SB_MBS_COST_START AND ISNULL(DEF_ALT_MIC.SB_MBS_COST_END, DATEADD(Y,100,GETDATE()))
                INNER JOIN SB_COST_TYPE_CRITERIA DEF_ALT_CTC with (nolock) ON DEF_ALT_CTC.SB_COST_TYPE_ID = DEF_ALT_MIC.SB_COST_TYPE_ID
                INNER JOIN SB_ITEM_TYPE DEF_ALT_ITYPE with (nolock) ON DEF_ALT_CTC.SB_ITEM_TYPE_CODE = DEF_ALT_ITYPE.SB_ITEM_TYPE_CODE
                LEFT OUTER JOIN SB_MBS_ITEM_COST ALT_DEFAULT_ITEM_COST2 with (nolock)
                    ON  ALT_DEFAULT_ITEM_COST2.SB_MBS_ITEM_NUMBER = ORIGINAL.SB_MBS_ITEM_NUMBER
                    AND ALT_DEFAULT_ITEM_COST2.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID#
                    AND ORIGINAL.SB_SERVICE_DATE BETWEEN ALT_DEFAULT_ITEM_COST2.SB_MBS_COST_START AND ISNULL(ALT_DEFAULT_ITEM_COST2.SB_MBS_COST_END,'31-DEC-3100')
                WHERE DEF_ALT_CTC.SB_FIN_CLASS_TYPE_CODE = ORIGINAL.SB_FIN_CLASS_TYPE_CODE
                    AND DEF_ALT_MIC.SB_MBS_ITEM_FEE > 0
                ) FEES
            ORDER BY SB_PRIORITY, SB_MBS_COST_START DESC
        </cfquery>

        <cfif ALTERNATE_ITEM_FEE.RECORDCOUNT GT 0>
            <cfquery name="UPDATE_ITEM_COST" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                UPDATE SB_CONING_RUN
                SET SB_SCHEDULE_FEE = <cfif ALTERNATE_ITEM_FEE.SB_SCHEDULE_FEE eq "">NULL<cfelse>#ALTERNATE_ITEM_FEE.SB_SCHEDULE_FEE#</cfif>,
                    SB_ACTUAL_FEE = <cfif ALTERNATE_ITEM_FEE.SB_ACTUAL_FEE eq "">NULL<cfelse>#ALTERNATE_ITEM_FEE.SB_ACTUAL_FEE#</cfif>,
                    SB_ACTUAL_FEE_75 = <cfif ALTERNATE_ITEM_FEE.SB_ACTUAL_FEE_75 eq "">NULL<cfelse>#ALTERNATE_ITEM_FEE.SB_ACTUAL_FEE_75#</cfif>,
                    SB_DERIVED_NOGAP_PERCENT = <cfif ALTERNATE_ITEM_FEE.SB_DERIVED_NOGAP_PERCENT eq "">NULL<cfelse>#ALTERNATE_ITEM_FEE.SB_DERIVED_NOGAP_PERCENT#</cfif>,
                    SB_ITEM_NUMBER = '#ALTERNATE_ITEM_FEE.SB_MBS_ITEM_NUMBER#',
                    SB_CONING_ITEM_TYPE = '#ALTERNATE_ITEM_FEE.SB_ITEM_TYPE_CODE#',
                    SB_APPLY_CONING = <cfif ALTERNATE_ITEM_FEE.SB_APPLY_CONING_RULES eq "">NULL<cfelse>'#ALTERNATE_ITEM_FEE.SB_APPLY_CONING_RULES#'</cfif>
                FROM SB_CONING_RUN
                WHERE SB_CONING_ID = #MISSING_COST.SB_CONING_ID#
            </cfquery>

            <cfquery name="UPDATE_INVOICE_ITEM_VIEW" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                UPDATE SB_INVOICE_ITEM
                SET SB_INVOICE_ITEM.ITEM_VIEW_ID = #ALTERNATE_ITEM_FEE.ITEM_VIEW_ID#,
                    SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER = SB_CONING_RUN.SB_ITEM_NUMBER,
                    SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
                    SB_INVOICE_ITEM.SB_UPDATED_BY =
                        <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                            <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
                        <cfelse>
                            'pbrc-ae:ACL'
                        </cfif>,
                    SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
                    SB_UPDATED_FROM = 'apply_coning_logic UPDATE_INVOICE_ITEM_VIEW'
                    FROM
                    SB_CONING_RUN
                    INNER JOIN SB_INVOICE_ITEM ON SB_CONING_RUN.SB_CONING_ITEM_ID = SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID
                    INNER JOIN SB_INVOICE with (nolock) ON SB_INVOICE_ITEM.SB_INVOICE_ID = SB_INVOICE.SB_INVOICE_ID
                WHERE
                    SB_CONING_ID = #MISSING_COST.SB_CONING_ID#
            </cfquery>
        </cfif>
     </cfoutput> <!--- Finished assessing and transforming CONING_RUN records in MISSING_COST --->

    <!--- If another invoice already exists with the right item type, move the invoice --->
    <!--- Check to see if there is an existing invoice matching the episode, provider, specialty and item type and batch--->
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MISSING_COST_RECORDS">
         SELECT DISTINCT
            CR.SB_CONING_ID,
            I.SB_INVOICE_ID AS ORIG_INV_ID,
            CASE WHEN MAX(REL_INV.SB_INVOICE_ID) IS NOT NULL AND I.SB_INVOICE_ID <> MAX(REL_INV.SB_INVOICE_ID) THEN 1 ELSE 0 END AS REL_INV_FOUND,
            MAX(REL_INV.SB_INVOICE_ID) AS REL_INV_ID
        FROM
            SB_CONING_RUN CR
            INNER JOIN SB_INVOICE_ITEM II with (nolock) ON II.SB_INVOICE_ITEM_ID = CR.SB_CONING_ITEM_ID
            INNER JOIN SB_INVOICE I with (nolock) ON I.SB_INVOICE_ID = II.SB_INVOICE_ID
            LEFT OUTER JOIN SB_INVOICE REL_INV with (nolock) ON REL_INV.SB_EPISODE_NUMBER = I.SB_EPISODE_NUMBER
                AND REL_INV.SB_INVOICE_DATE IS NULL
                AND REL_INV.SB_ITEM_TYPE_CODE LIKE CR.SB_CONING_ITEM_TYPE
                AND REL_INV.SB_PROVIDER_NUMBER LIKE CR.SB_CONING_PROVIDER
                AND REL_INV.SB_SPECIALTY_CODE LIKE CR.SB_CONING_SPECIALTY_CODE
            LEFT OUTER JOIN SB_INVOICE_ITEM REL_ITEM with (nolock) ON REL_INV.SB_INVOICE_ID = REL_ITEM.SB_INVOICE_ID
                AND REL_ITEM.SB_INV_BATCH_ID = II.SB_INV_BATCH_ID
        WHERE
            CR.SB_CONING_ID IN (#ORG_MISSING_COST_LIST_CONING_ID#)
        GROUP BY CR.SB_CONING_ID,I.SB_INVOICE_ID
    </cfquery>

    <cfloop query="MISSING_COST_RECORDS">
        <cfset ATTACHED_INVOICE_ID = MISSING_COST_RECORDS.ORIG_INV_ID>
        <cfif MISSING_COST_RECORDS.REL_INV_FOUND eq 1>
            <!--- If a relevant invoice exist, move the item to the new invoice --->
            <cfset ATTACHED_INVOICE_ID = MISSING_COST_RECORDS.REL_INV_ID>
        <cfelse>
            <!--- If no relavant invoice was found, check if there are any item type conflicts --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ITEM_TYPE_CONFLICTS">
                SELECT DISTINCT INV.SB_EPISODE_NUMBER,
                CR.SB_CONING_ITEM_TYPE
                FROM SB_CONING_RUN CR
                INNER JOIN SB_INVOICE INV ON INV.SB_INVOICE_ID = CR.SB_CONING_INVOICE_ID
                INNER JOIN SB_INVOICE_ITEM INVI on INVI.SB_INVOICE_ID = CR.SB_CONING_INVOICE_ID
                WHERE INV.SB_INVOICE_ID IN (
                    SELECT INVOICE.SB_INVOICE_ID
                    FROM SB_INVOICE INVOICE
                    INNER JOIN SB_INVOICE_ITEM ITEM ON ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID
                    INNER JOIN SB_MBS_ITEM MBSITEM ON MBSITEM.SB_MBS_ITEM_NUMBER = ITEM.SB_MBS_ITEM_NUMBER
                    WHERE INVOICE.SB_INVOICE_ID = #MISSING_COST_RECORDS.ORIG_INV_ID#
                    GROUP BY INVOICE.SB_INVOICE_ID HAVING COUNT(DISTINCT MBSITEM.SB_ITEM_TYPE_CODE) > 1
                )
            </cfquery>

            <cfif ITEM_TYPE_CONFLICTS.recordcount neq 0>
                <!--- If item type conflict within invoice is found, create new invoice and move the items, update the invoice_ref  --->
                <!--- Calculate the new invoice number --->
                <cfinvoke component="pbrc-ae.components.Invoice" method="PreInvoiceNumber" returnvariable="VARIABLES.INVOICE_NUMBER">
                <cfinvokeargument name="SB_EPISODE_NUMBER" value='#ITEM_TYPE_CONFLICTS.SB_EPISODE_NUMBER#'/>
                </cfinvoke>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="INSERT_INVOICE">
                    set nocount on
                    INSERT INTO SB_INVOICE
                    (
                        SB_EPISODE_NUMBER,
                        SB_INVOICE_TYPE_CODE,
                        SB_INVOICE_NUMBER,
                        SB_INVOICE_DATE,
                        SB_INVOICE_RECEIVED,
                        SB_PROVIDER_NUMBER,
                        SB_PATIENT_MRN,
                        SB_HL7_SOURCE,
                        SB_INVOICE_STATUS_CODE,
                        SB_DEBTOR_ID,
                        SB_BILL_MECH_CODE,
                        SB_INVOICE_TOTAL_AMT,
                        SB_SPECIALTY_CODE,
                        SB_CHART_OF_ACC_ID,
                        SB_ITEM_TYPE_CODE,
                        SB_SOURCE_CODE,
                        SB_UPDATED_BY,
                        SB_UPDATE_DATE,
                        SB_UPDATED_FROM
                    )
                    SELECT
                        SB_EPISODE_NUMBER,
                        SB_INVOICE_TYPE_CODE,
                        '#VARIABLES.INVOICE_NUMBER#',
                        null,
                        SB_INVOICE_RECEIVED,
                        SB_PROVIDER_NUMBER,
                        SB_PATIENT_MRN,
                        SB_HL7_SOURCE,
                        SB_INVOICE_STATUS_CODE,
                        SB_DEBTOR_ID,
                        SB_BILL_MECH_CODE,
                        SB_INVOICE_TOTAL_AMT,
                        SB_SPECIALTY_CODE,
                        SB_CHART_OF_ACC_ID,
                        SB_ITEM_TYPE_CODE,
                        SB_SOURCE_CODE,
                        SB_UPDATED_BY,
                        GETDATE(),
                        'apply_coning_logic INSERT_INVOICE'
                    FROM SB_INVOICE
                    WHERE SB_INVOICE_ID = #MISSING_COST_RECORDS.ORIG_INV_ID#

                    select SCOPE_IDENTITY() as SB_INVOICE_ID
                </cfquery>
                <cfset ATTACHED_INVOICE_ID = INSERT_INVOICE.SB_INVOICE_ID>
            </cfif>
        </cfif>

            <!--- Copy invoice error flags from the original; only if the attached invoice_id does not match the original invoice_id  --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="copy_invoice_flags">
                INSERT INTO SB_INVOICE_ERROR
                (SB_INVOICE_FLAG_CODE,
                SB_INVOICE_ID,
                SB_ERROR_DATE,
                SB_FINALISED_DATE,
                SB_ERROR_COMMENT,
                SB_UPDATED_BY,
                SB_UPDATE_DATE)
                SELECT SB_INVOICE_FLAG_CODE,
                <CFQUERYPARAM CFSQLTYPE="CF_SQL_NUMERIC" VALUE="#ATTACHED_INVOICE_ID#">,
                SB_ERROR_DATE,
                SB_FINALISED_DATE,
                SB_ERROR_COMMENT,
                SB_UPDATED_BY,
                SB_UPDATE_DATE
                FROM SB_INVOICE_ERROR
                WHERE 1=1
                AND SB_INVOICE_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.ORIG_INV_ID#">
                AND <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.ORIG_INV_ID#"> <> <cfqueryparam cfsqltype="cf_sql_numeric" value="#ATTACHED_INVOICE_ID#">
            </cfquery>

            <!--- Update the INVOICE ITEM's Linked INVOICE details; only if the original invoice_id does not match the attached invoice_id --->
            <cfquery name="UPDATE_ITEM_INVOICE_ID" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                UPDATE SB_INVOICE_ITEM
                    SET SB_INVOICE_ID =  <cfqueryparam cfsqltype="cf_sql_numeric" value="#ATTACHED_INVOICE_ID#">,
                    SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
                    SB_INVOICE_ITEM.SB_UPDATED_BY =
                    <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                        <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
                    <cfelse>
                        'pbrc-ae:ACL'
                    </cfif>,
                    SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
                    SB_UPDATED_FROM = 'apply_coning_logic UPDATE_ITEM_INVOICE_ID'
                FROM
                    SB_CONING_RUN
                    INNER JOIN SB_INVOICE_ITEM ON SB_CONING_RUN.SB_CONING_ITEM_ID = SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID
                    INNER JOIN SB_INVOICE with (nolock) ON SB_INVOICE_ITEM.SB_INVOICE_ID = SB_INVOICE.SB_INVOICE_ID
                WHERE
                    SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.SB_CONING_ID#">
                    AND SB_CONING_INVOICE_ID <> <cfqueryparam cfsqltype="cf_sql_numeric" value="#ATTACHED_INVOICE_ID#">
            </cfquery>

            <!--- Delete invoice error flags of orphaned invoices;the invoices with no items --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DELETE_INVOICE_FLAG">
                DELETE INV_ERROR
                FROM SB_INVOICE_ERROR INV_ERROR
                LEFT OUTER JOIN SB_INVOICE_ITEM ITEM with (nolock) ON ITEM.SB_INVOICE_ID = INV_ERROR.SB_INVOICE_ID
                LEFT OUTER JOIN SB_INVOICE_ITEM_DELETED ITEM_DEL with (nolock) ON ITEM_DEL.SB_INVOICE_ID = INV_ERROR.SB_INVOICE_ID
                WHERE INV_ERROR.SB_INVOICE_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.ORIG_INV_ID#">
                AND ITEM.SB_INVOICE_ITEM_ID IS NULL
                AND ITEM_DEL.SB_INVOICE_ITEM_ID2 IS NULL
            </cfquery>

            <!--- Delete orphaned invoices; the invoices with no items--->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DELETE_INVOICE">
                DELETE INV
                FROM SB_INVOICE INV
                LEFT OUTER JOIN SB_INVOICE_ITEM ITEM with (nolock) ON ITEM.SB_INVOICE_ID = INV.SB_INVOICE_ID
                LEFT OUTER JOIN SB_INVOICE_ITEM_DELETED ITEM_DEL with (nolock) ON ITEM_DEL.SB_INVOICE_ID = INV.SB_INVOICE_ID
                WHERE INV.SB_INVOICE_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.ORIG_INV_ID#">
                AND ITEM.SB_INVOICE_ITEM_ID IS NULL
                AND ITEM_DEL.SB_INVOICE_ITEM_ID2 IS NULL
            </cfquery>

            <!--- Update the linked invoice_id reference of CONING_RUN record --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_INVOICE_REF">
                UPDATE SB_CONING_RUN
                SET SB_CONING_INVOICE_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ATTACHED_INVOICE_ID#">
                FROM SB_CONING_RUN
                WHERE 1=1
                AND SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_RECORDS.SB_CONING_ID#">
                AND SB_CONING_INVOICE_ID <> <cfqueryparam cfsqltype="cf_sql_numeric" value="#ATTACHED_INVOICE_ID#">
            </cfquery>
    </cfloop>
    <!--- Update the invoice type if the attached INVOICE needs updating --->
    <cfquery name="UPDATE_INVOICE_TYPE" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        UPDATE INV
            SET INV.SB_ITEM_TYPE_CODE = MBSITEM.SB_ITEM_TYPE_CODE,
            INV.SB_UPDATED_BY =
                <cfif isDefined("SESSION.SB_LOGIN_CODE") and SESSION.SB_LOGIN_CODE neq "">
                    <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
                <cfelse>
                    'pbrc-ae:ACL'
                </cfif>,
            INV.SB_UPDATE_DATE = getDate()
        FROM SB_INVOICE INV
        INNER JOIN SB_CONING_RUN CR ON INV.SB_INVOICE_ID = CR.SB_CONING_INVOICE_ID
        INNER JOIN SB_INVOICE_ITEM ITEM ON ITEM.SB_INVOICE_ITEM_ID = CR.SB_CONING_ITEM_ID
        INNER JOIN SB_MBS_ITEM MBSITEM ON MBSITEM.SB_MBS_ITEM_NUMBER = ITEM.SB_MBS_ITEM_NUMBER
        WHERE 1=1
        AND CR.SB_CONING_ID IN (#ORG_MISSING_COST_LIST_CONING_ID#)
        AND MBSITEM.SB_ITEM_TYPE_CODE NOT LIKE INV.SB_ITEM_TYPE_CODE
    </cfquery>

    <!--- Review the bill mech all coning records with missing cost --->
    <cfquery name="MISSING_COST_REVIEW_BILL_MECH" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        SELECT SB_INVOICE_TYPE.SB_DISABLE_COSTING, INV.SB_INVOICE_ID
        FROM SB_CONING_RUN CR
        INNER JOIN SB_INVOICE INV ON INV.SB_INVOICE_ID = CR.SB_CONING_INVOICE_ID
        INNER JOIN SB_INVOICE_TYPE with (nolock) ON INV.SB_INVOICE_TYPE_CODE = SB_INVOICE_TYPE.SB_INVOICE_TYPE_CODE
        WHERE CR.SB_CONING_ID IN (#ORG_MISSING_COST_LIST_CONING_ID#)
    </cfquery>

    <cfoutput query="MISSING_COST_REVIEW_BILL_MECH">
        <cfinvoke component="pbrc-ae.components.allocate_bill_mech"
            method="allocate"
            returnvariable="none">
                <cfinvokeargument name="sb_invoice_id" value="#MISSING_COST_REVIEW_BILL_MECH.SB_INVOICE_ID#">
            <cfif MISSING_COST_REVIEW_BILL_MECH.SB_DISABLE_COSTING eq 'Y'>
                <cfinvokeargument name="apply_bill_mech" value="N">
            </cfif>
        </cfinvoke>
     </cfoutput>

    <!--- Update the Bill Mech related values in the CONING_RUN record --->
    <cfquery name="UPDATE_ITEM_COST" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        UPDATE SB_CONING_RUN
        SET SB_CONING_STATUS_CODE = MECH.SB_INITIAL_ITEM_STATUS,
        SB_CONING_BILL_MECH =
        CASE WHEN EPISODE.SB_EPISODE_TYPE_CODE = 'P'
         THEN 'P'
        WHEN INVOICE.SB_BILL_MECH_CODE = 'B' AND EPISODE.SB_MC_FORM_SIGNED = 'Y' AND SB_MEDICARE_IMAGE_FILENAME IS NOT NULL THEN
            'B'
        ELSE
            ISNULL(INVOICE.SB_RERAISE_BILL_MECH, CRITERIA.SB_BILL_MECH_CODE)
        END
        FROM SB_CONING_RUN
        INNER JOIN SB_INVOICE INVOICE with (nolock) ON INVOICE.SB_INVOICE_ID =  SB_CONING_RUN.SB_CONING_INVOICE_ID
        INNER JOIN SB_PATIENT_EPISODE EPISODE with (nolock) ON EPISODE.SB_EPISODE_NUMBER = INVOICE.SB_EPISODE_NUMBER
        LEFT OUTER JOIN SB_COST_TYPE_CRITERIA CRITERIA with (nolock) ON CRITERIA.SB_COST_TYPE_CRITERIA_ID = INVOICE.SB_COST_TYPE_CRITERIA_ID
        LEFT OUTER JOIN SB_BILLING_MECHANISM MECH  with (nolock) ON IsNull(Invoice.SB_RERAISE_BILL_MECH, CRITERIA.SB_BILL_MECH_CODE) = MECH.SB_BILL_MECH_CODE
        WHERE SB_CONING_ID IN (#ORG_MISSING_COST_LIST_CONING_ID#)
    </cfquery>

    <!--- Flag error status if scheduled fee is still missing --->
    <cfquery name="STILL_MISSING" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
         SELECT SB_CONING_ID, SB_CONING_ITEM_ID
         FROM   SB_CONING_RUN
         WHERE
         SB_SCHEDULE_FEE IS NULL AND
         SB_APPLY_CONING = 'N' AND
         SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
    </cfquery>

    <cfoutput query="STILL_MISSING">
         <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
         <cfset VARIABLES.ERROR_TEXT = 'Item Cost could not be determined'>

         <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
            UPDATE  SB_CONING_RUN
            SET     SB_CONING_STATUS_CODE = 'ER',
                    SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
            WHERE   SB_CONING_ITEM_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#STILL_MISSING.SB_CONING_ITEM_ID#">
                AND SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#STILL_MISSING.SB_CONING_ID#">
         </cfquery>
    </cfoutput>
</cfif><!--- END default cost mapping transformation --->


  <!---
    Find any AMA  records that have a zero cost and update the coning_record with an error message --->
  <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MISSING_COST_CRITERIA">
     SELECT
        SB_CONING_ID, SB_CONING_ITEM_ID
     FROM
        SB_CONING_RUN   INNER JOIN
        SB_MBS_ITEM with (nolock) ON
            SB_CONING_RUN.SB_ITEM_NUMBER  = SB_MBS_ITEM.SB_MBS_ITEM_NUMBER
     WHERE
     SB_SCHEDULE_FEE = 0 AND
     (SB_ACTUAL_FEE = 0 OR SB_ACTUAL_FEE IS NULL) AND
     SB_MBS_ITEM.SB_ITEM_TYPE_CODE = 'A' AND
     SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
 </cfquery>

 <cfif MISSING_COST_CRITERIA.RECORDCOUNT NEQ 0>

     <cfoutput query="MISSING_COST_CRITERIA">

         <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
         <cfset VARIABLES.ERROR_TEXT = 'The AMA Item Price needs to be over written.'>

         <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
         UPDATE SB_CONING_RUN
            SET
                SB_CONING_STATUS_CODE = 'ER',
                SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
            WHERE
                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_CRITERIA.SB_CONING_ID#">
         </cfquery>
     </cfoutput>
 </cfif>





<!--- .............................................. --->
<!--- Edit checks originally specified by Imaging are included here.
These are not so much coning rules as sensible edits.


srt, 04-dec-2007 added request date
--->

<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="EditChecks">
    SELECT  SB_CONING_RUN.*,
            Case when sb_mbs_item.sb_mbs_item_number between '65060' and '79999'
                then 'P'
             when sb_mbs_item.sb_hicol_service_type = 'O'
                then 'O'
             when SB_HIC_SPECIALTY.SB_HIC_SPECIALIST = 'Y'
                then 'S'
             else 'O'
        end as service_type,
        EPISODE.SB_EPISODE_TYPE_CODE,
        EPISODE.SB_REFFERAL_DATE_ON_LETTER,
        EPISODE.SB_REFERRAL_DATE,

        ITEM.SB_REQUEST_DATE,
        ISNULL(CLINIC.SB_REQUEST_OR_REFERRAL, 'R') AS SB_REQUEST_OR_REFERRAL,
        ISNULL(SB_ITEM_TYPE.SB_SERVICE_PROV_REQUIRED, 'N') AS SB_SERVICE_PROV_REQUIRED
    FROM
        SB_CONING_RUN   INNER JOIN
        sb_mbs_item with (nolock) ON
            SB_CONING_RUN.SB_ITEM_NUMBER = sb_mbs_item.SB_MBS_ITEM_NUMBER INNER JOIN
        SB_INVOICE_ITEM ITEM  ON
            SB_CONING_RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
        SB_INVOICE INVOICE  ON
            ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
        SB_PATIENT_EPISODE EPISODE  ON
            INVOICE.SB_EPISODE_NUMBER = EPISODE.SB_EPISODE_NUMBER LEFT OUTER JOIN
        sb_provider with (nolock) ON
            SB_CONING_RUN.SB_CONING_PROVIDER = sb_provider.SB_PROVIDER_NUMBER LEFT OUTER JOIN
        SB_HIC_SPECIALTY with (nolock) ON
            sb_provider.SB_HIC_SPECIALTY_CODE = SB_HIC_SPECIALTY.SB_HIC_SPECIALTY_CODE LEFT OUTER JOIN
        SB_CLINIC CLINIC ON
            EPISODE.SB_CLINIC_CODE = CLINIC.SB_CLINIC_CODE
        LEFT OUTER JOIN SB_ITEM_TYPE on SB_ITEM_TYPE.SB_ITEM_TYPE_CODE = sb_mbs_item.SB_ITEM_TYPE_CODE
    WHERE
        SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
    ORDER BY
            SB_CONING_INVOICE_ID

</cfquery>


<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="PatDem">
    select  SB_PATIENT_REGISTER.SB_PATIENT_SURNAME,
            SB_PATIENT_REGISTER.SB_PATIENT_OTHER_NAMES,
            SB_PATIENT_REGISTER.SB_PATIENT_SEX,
            SB_PATIENT_REGISTER.SB_PATIENT_DOB,
            LTRIM(RTRIM(SB_PATIENT_REGISTER.SB_PATIENT_MEDICARE_NUMBER)) AS SB_PATIENT_MEDICARE_NUMBER,
            LTRIM(RTRIM(SB_PATIENT_REGISTER.SB_MEDICARE_NO_REF)) AS SB_MEDICARE_NO_REF,
            SB_PATIENT_REGISTER.SB_DVA_NUMBER
    from    SB_PATIENT_REGISTER
    where   SB_PATIENT_REGISTER.sb_patient_mrn = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
      and   SB_PATIENT_REGISTER.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">

</cfquery>


    <cfloop query="PharmacyErrorCheck">

        <cfset inv_related_error = "">

            <!--- SCOTT....... CHECK PHARMACY DEBTOR --->
            <cfif PharmacyErrorCheck.RECORDCOUNT GT 0 AND (PharmacyErrorCheck.SB_DEBTOR_ADDRESS_1 eq ""
               or PharmacyErrorCheck.SB_DEBTOR_SUBURB eq ""
               or PharmacyErrorCheck.SB_DEBTOR_POSTCODE eq "")>

                  <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_INVOICE_ERROR">
                    UPDATE SB_INVOICE_ITEM
                        SET
                            SB_ITEM_STATUS_CODE = 'ER',
                            SB_OUTPAT_ERROR = LEFT(SB_OUTPAT_ERROR + ' Patient debtor address not fully specified.', 300),
                            SB_UPDATED_BY =
                                <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                                    <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
                                <cfelse>
                                    'pbrc-ae:ACL'
                                </cfif>,
                            SB_UPDATE_DATE = getDate(),
                            SB_UPDATED_FROM = 'apply_coning_logic UPDATE_INVOICE_ERROR'
                    WHERE
                        SB_INVOICE_ID = #PharmacyErrorCheck.SB_INVOICE_ID#
                  </cfquery>


               </cfif>


    </cfloop>




<cfset this_invoice_id = "first">
<cfset coning_hist_date = '1-Jan-2200'>





<cfoutput query="EditChecks">
    <cfset pat_error = "">

    <!--- Patient demographics include an address line, suburb and postcode
          Patient sex has been specified
          Patient has first name and surname
          Medicare number is valid (bulk bill bill mech)
          Vet Affairs number exists (vet affairs bill mech)
     --->

    <cfif PatDem.SB_PATIENT_SURNAME neq 'FORENSIC' and PatDem.SB_PATIENT_SURNAME neq 'FORENSICS'>
        <cfif PatDem.SB_PATIENT_SURNAME eq "" or PatDem.SB_PATIENT_OTHER_NAMES eq "">
            <cfset pat_error = Trim(pat_error & " Patient name not fully specified.")>
        </cfif>
        <cfif ListfindNoCase('M,F',PatDem.SB_PATIENT_SEX) eq 0>
            <cfset pat_error = Trim(pat_error & " Patient gender not specified.")>
        </cfif>
    </cfif>
    <!---
        Medicare number is valid

        srt, 13-07-2006, made use of cfelseif to reduce number of errors

    --->
    <cfif ListfindNoCase('B,BM,AG,SC,M',EditChecks.SB_CONING_BILL_MECH) neq 0>
        <cfif PatDem.SB_PATIENT_MEDICARE_NUMBER eq "">
            <cfset pat_error = Trim(pat_error & " No medicare number.")>
        <cfelseif not isnumeric(PatDem.SB_MEDICARE_NO_REF) or PatDem.SB_MEDICARE_NO_REF eq "0" >
            <cfset pat_error = Trim(pat_error & " Invalid medicare ref no.")>
        <cfelseif isnumeric(PatDem.SB_PATIENT_MEDICARE_NUMBER) and len(PatDem.SB_PATIENT_MEDICARE_NUMBER) eq 10 >

            <cfset check_dig = (Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,1,1)
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,2,1) * 3
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,3,1) * 7
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,4,1) * 9
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,5,1)
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,6,1) * 3
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,7,1) * 7
                             +  Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,8,1) * 9) mod 10>
            <cfif check_dig neq Mid(PatDem.SB_PATIENT_MEDICARE_NUMBER,9,1)>
                <cfset pat_error = Trim(pat_error & " Invalid medicare check digit.")>
            </cfif>
        <cfelseif NOT isnumeric(PatDem.SB_PATIENT_MEDICARE_NUMBER) >
            <cfset pat_error = Trim(pat_error & " Medicare Number invalid.")>
        </cfif>
    </cfif>
    <!---     DVA number exists --->
    <cfif ListfindNoCase('DV,DM',EditChecks.SB_CONING_BILL_MECH) neq 0>
        <cfset dva_ok = "N">
        <cfif PatDem.SB_DVA_NUMBER neq "" and PatDem.SB_PATIENT_OTHER_NAMES neq ""
                and PatDem.SB_PATIENT_SURNAME neq "" and PatDem.SB_PATIENT_SEX neq ""
                and PatDem.SB_PATIENT_DOB neq "">
            <cfset dva_ok = "Y">
        </cfif>

        <cfif dva_ok eq "N">
            <cfset pat_error = pat_error & "DVA claim requires DVA No + first name + surname + dob + gender.">
        </cfif>

        <cfif PatDem.SB_DVA_NUMBER neq "">
            <cfif Len(PatDem.SB_DVA_NUMBER) lt 5>
                <cfset pat_error = Trim(pat_error & " Invalid DVA number.")>
            <cfelseif Left(UCase(PatDem.SB_DVA_NUMBER),1) lt 'A' or Left(UCase(PatDem.SB_DVA_NUMBER),1) gt 'Z'>
                <cfset pat_error = Trim(pat_error & " Invalid DVA number.")>
            </cfif>
        </cfif>
    </cfif>

<!--- Find the minimum service day being coned, which will be assumed to be the date that determines which
historical version of a coning rule will be applied. --->
    <cfif APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_SERVICE_DATE) lt APPLICATION.dateFunctions.parseDateTimeWithNULL(coning_hist_date)>
        <cfset coning_hist_date = DateFormat(EditChecks.SB_SERVICE_DATE,"dd-mmm-yyyy")>
    </cfif>
    <cfset edit_error_text = pat_error>
<!--- Billing Mechanism is defined --->
    <cfif EditChecks.SB_CONING_BILL_MECH eq "">
        <cfset EditChecks.SB_CONING_BILL_MECH = "N">


        <cfset edit_error_text = Trim(edit_error_text & " Billing Mechanism is not defined.")>
    </cfif>

<!---   Provider is not required for prosthesis and pharmacy items --->
    <cfif FindNoCase(EditChecks.SB_CONING_ITEM_TYPE, item_types_not_requiring_specialist) eq 0 and EditChecks.SB_SERVICE_PROV_REQUIRED eq 'Y'>
    <!---   Provider and modality combination is valid --->
        <cfif EditChecks.SB_CONING_SPEC_PROV_DEFINED EQ "N">
            <cfset edit_error_text = Trim(edit_error_text & " Provider / Specialty Combination is invalid.")>

        </cfif>
    <!--- Radiologist provider number exists in platypus --->
        <cfif EditChecks.SB_SERV_PROV_VALID eq "N">
            <cfset edit_error_text = Trim(edit_error_text & " Provider is invalid - " & EditChecks.SB_CONING_PROVIDER)>
        </cfif>
    </cfif>

<!--- Hospital is valid --->
    <cfif EditChecks.SB_CONING_HOSP_VALID eq "N">
        <cfset edit_error_text = Trim(edit_error_text & " Hospital is invalid.")>
    </cfif>
<!--- Financial Classification is valid --->
    <cfif EditChecks.SB_CONING_FIN_CLASS_VALID eq "N">
        <cfset edit_error_text = Trim(edit_error_text & " Financial Classification is invalid.")>
    </cfif>

    <cfif isnull(inv_related_error)>
        <cfset inv_related_error = "">
    </cfif>

    <cfif this_invoice_id neq EditChecks.SB_CONING_INVOICE_ID
      and (EditChecks.SB_CONING_BILL_MECH eq "DD") >
        <cfset this_invoice_id = EditChecks.SB_CONING_INVOICE_ID>
        <cfset inv_related_error = "">
        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DebtorAddr">
            SELECT  SB_DEBTOR.SB_DEBTOR_ADDRESS_1,
                    SB_DEBTOR.SB_DEBTOR_SUBURB,
                    SB_DEBTOR.SB_DEBTOR_POSTCODE
            FROM    dbo.SB_DEBTOR
                        INNER JOIN
                    dbo.SB_INVOICE   ON SB_DEBTOR.SB_DEBTOR_ID = SB_INVOICE.SB_DEBTOR_ID
                        INNER JOIN
                    dbo.SB_INVOICE_ITEM   ON SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID
            WHERE
                SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#EditChecks.SB_CONING_ITEM_ID#">
        </cfquery>


        <cfif DebtorAddr.RECORDCOUNT EQ 0
           or DebtorAddr.SB_DEBTOR_ADDRESS_1 eq ""
           or DebtorAddr.SB_DEBTOR_SUBURB eq ""
           or DebtorAddr.SB_DEBTOR_POSTCODE eq "">

            <cfset inv_related_error = Trim(edit_error_text & " Invoice debtor address not fully specified.")>

        </cfif>

    </cfif>
    <cfset edit_error_text = Trim(edit_error_text & inv_related_error)>


<!--- Exam dates are within admission dates --->
    <!--- The following dates could be null and there for can not be parsed through APPLICATION.dateFunctions.parseDateTimeWithNULL() this needs to be handled. --->
    <cfif EditChecks.SB_CONING_ADMIT_DATE eq ''>
        <cfset sb_coning_admit_date_comparison = ''>
    <cfelse>
        <cfset sb_coning_admit_date_comparison = APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(EditChecks.SB_CONING_ADMIT_DATE,'YYYY-MM-DD'))>
    </cfif>
    <cfif EditChecks.SB_SERVICE_DATE eq ''>
        <cfset sb_service_date_comparison = ''>
    <cfelse>
        <cfset sb_service_date_comparison = APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_SERVICE_DATE)>
    </cfif>
    <cfif EditChecks.SB_SERVICE_DATE eq ''>
        <cfset sb_service_date_ymd_comparison = ''>
    <cfelse>
        <cfset sb_service_date_ymd_comparison = APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(EditChecks.SB_SERVICE_DATE,'YYYY-MM-DD'))>
    </cfif>
    <cfif EditChecks.SB_REQUEST_DATE eq ''>
        <cfset sb_request_date_comparison = ''>
    <cfelse>
        <cfset sb_request_date_comparison = APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(EditChecks.SB_REQUEST_DATE,'YYYY-MM-DD'))>
    </cfif>


    <cfif sb_coning_admit_date_comparison gt sb_service_date_comparison>
        <cfset edit_error_text = Trim(edit_error_text & " Service prior to admission.")>
    </cfif>
    <cfif
        EditChecks.SB_CONING_ITEM_TYPE   NEQ "T" and<!--- not a medical report --->
        EditChecks.SB_CONING_DISCH_DATE neq ""
      and APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(EditChecks.SB_CONING_DISCH_DATE,'YYYY-MM-DD')) lt APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(EditChecks.SB_SERVICE_DATE,'YYYY-MM-DD'))>
        <cfset edit_error_text = Trim(edit_error_text & " Service after discharge.")>
    </cfif>
    <!---
        Exam code is on or after request date
    --->

    <cfif sb_service_date_ymd_comparison lt sb_request_date_comparison>
        <cfset edit_error_text = Trim(edit_error_text & " Service date before request date.")>
    </cfif>



<!--- Item number is valid for medicare (for bulk bill and vet affairs) --->
    <cfif ListfindNoCase('B,BM,AG,SC,M,E,DV,DM',EditChecks.SB_CONING_BILL_MECH) neq 0>
        <cfif EditChecks.SB_CONING_ITEM_TYPE NEQ 'M'>
            <cfset edit_error_text = Trim(edit_error_text & " Item code must be MBS.")>
        </cfif>
    </cfif>

<!---
If not interhospital, corp or private inpatient, check referring provider is valid
and not a prosthesis item
--->

    <cfif EditChecks.SB_CONING_DEFENCE neq "y" and ListfindNoCase('H,C,PI',EditChecks.SB_CONING_BILL_MECH) eq 0
      AND EditChecks.SB_CONING_REFERRAL_OVERRIDE EQ ""
      and EditChecks.SB_CONING_ITEM_TYPE neq "r"
      and EditChecks.SB_CONING_ITEM_TYPE neq "o"
      and EditChecks.SB_CONING_ITEM_TYPE neq "d"
      and EditChecks.SB_CONING_ITEM_TYPE neq "e"
      and EditChecks.SB_CONING_ITEM_TYPE neq "i"
      and EditChecks.SB_CONING_ITEM_TYPE neq "t"
      and EditChecks.service_type neq "O">
        <cfset ALLOW_PROVIDER_VALIDATION = application.cache.getSysParam("ALLOW_PROVIDER_VALIDATION")>
        <cfif ALLOW_PROVIDER_VALIDATION EQ "Y">
            <!---
                Requesting dr has a start date
                Request date is inside the requesting dr start and end date

                srt, 04-12-2007 added request date portion to below cfelseif statment
                srt, 05-12-2004 job 2106, separated referral and request


                SB_REQUEST_OR_REFERRAL = (r = refferal) (q = request)
              --->
            <cfif EditChecks.SB_EPISODE_TYPE_CODE eq 'O' and
                EditChecks.SB_REFFERAL_DATE_ON_LETTER neq "" and EditChecks.SB_REQUEST_OR_REFERRAL EQ "R" and
                    (APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_CONING_REQ_PROV_START) gt APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_REFFERAL_DATE_ON_LETTER)
                   or APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_CONING_REQ_PROV_END) lt APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_REFFERAL_DATE_ON_LETTER))
            >

                <cfset edit_error_text = Trim(edit_error_text & ' Requesting Provider ' & EditChecks.SB_CONING_REQUEST_PROVIDER & ' start / end dates (#DateFormat(EditChecks.SB_CONING_REQ_PROV_START,"dd-mmm-yyyy")# - #DateFormat(EditChecks.SB_CONING_REQ_PROV_END,"dd-mmm-yyyy")#) do not match date on Letter #DateFormat(EditChecks.SB_REFFERAL_DATE_ON_LETTER,"dd-mmm-yyyy")#')>


            <cfelseif EditChecks.SB_EPISODE_TYPE_CODE eq 'O' and  EditChecks.SB_REQUEST_DATE neq "" and EditChecks.SB_REQUEST_OR_REFERRAL EQ "Q" AND
                    (APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_CONING_REQ_PROV_START) gt APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_REQUEST_DATE)
                   or APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_CONING_REQ_PROV_END) lt APPLICATION.dateFunctions.parseDateTimeWithNULL(EditChecks.SB_REQUEST_DATE))
            >

                <cfset edit_error_text = Trim(edit_error_text & ' Requesting Provider ' & EditChecks.SB_CONING_REQUEST_PROVIDER & ' start / end dates (#DateFormat(EditChecks.SB_CONING_REQ_PROV_START,"dd-mmm-yyyy")# - #DateFormat(EditChecks.SB_CONING_REQ_PROV_END,"dd-mmm-yyyy")#) do not match request date #DateFormat(EditChecks.SB_REQUEST_DATE,"dd-mmm-yyyy")#')>


            </cfif>
        </cfif>
    </cfif>

<!---   For items that are ED Comp/Inelig or OPD Comp/Ineli, if there is an inpatient episode
    on the same day, they cannot be claimed

    SRT, 10-06-2008. ADDED EPISODE DELTION DATE TO WHERE CLAUSE.

--->

    <cfif same_day_compensable neq "Y"
     and (EditChecks.SB_CONING_ITEM_TYPE eq "E"
       or EditChecks.SB_CONING_ITEM_TYPE eq "O")>
        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="InpatEp">
            set dateformat dmy
            SELECT
                Count(*) as cnt
            FROM
                dbo.SB_PATIENT_EPISODE
            WHERE
                SB_EPISODE_DELETION_DATE IS NULL
              AND   SB_PATIENT_MRN = '#ARGUMENTS.mrn#'
              and   SB_HL7_SOURCE = '#ARGUMENTS.source#'
              AND   '#DateFormat(EditChecks.SB_SERVICE_DATE,"dd-mmm-yyyy")#'
                    between CONVERT(DATETIME, CONVERT(VARCHAR, SB_ADMISSION_DATE,103))
                        and IsNull(CONVERT(DATETIME, CONVERT(VARCHAR, SB_ADMISSION_DATE,103)),GetDate())
                        and SB_EPISODE_TYPE_CODE = 'I'
        </cfquery>
        <cfif InpatEp.CNT GT 0>
            <cfset edit_error_text = Trim(edit_error_text & ' Compensable item cannot be raised when an inpatient stay occurred on the same day')>
        </cfif>

    </cfif>
<!--- The Fin Class from RIS does not conflict with that from PIMS.
i.e. If RIS specifies an inpatient fin class code, but there is no inpatient episode from PIMS, then an error will be flagged.

This edit check is not required, as it is covered by the cost determination functionality.
i.e. Entries in SB_COST_TYPE_CRITERIA specify valid combinations of fin class and episode type to give a billin mechanism
and cost type. If no match, then an error of "No Bill Mech", and "No Cost" will be given.
 --->

<!--- Update any errors into the coning run table. --->

    <cfif edit_error_text neq "">
         <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_EDIT_ERROR">
         UPDATE SB_CONING_RUN
            SET
                SB_CONING_STATUS_CODE = 'ER',
                SB_CONING_ERROR = LEFT('#edit_error_text#',3000)
            WHERE
                SB_CONING_ID = #EditChecks.SB_CONING_ID#
         </cfquery>
    </cfif>
</cfoutput>
<!--- .............................................. --->
<!---               End of edit checks               --->
<!--- .............................................. --->

<!---
slip this AMA coning rule in prior to exiting this procedure with SB_APPLY_CONING = 'N'.
Some diagnostic items cannot be raised for compensable patients --->
<cfif EditChecks.SB_CONING_FIN_CLASS_VALID eq "C">
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CompItem">
        select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
        from    SB_CONING_RULE_ITEM ,
                SB_CONING_RULE
        where   SB_RULE_START_DATE < '#coning_hist_date#'
          and   (SB_RULE_END_DATE IS NULL OR SB_RULE_END_DATE > '#coning_hist_date#')
          and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
          and   SB_RULE_CODE = 'COMP'
    </cfquery>

    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Compensable">
        SELECT
            SB_CONING_ID,
            SB_CONING_ERROR
         FROM   SB_CONING_RUN
         WHERE  SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
-- Applies to AMA codes only.
           AND  SB_CONING_ITEM_TYPE = 'A'
           <cfif application.cache.getSysParam("COMPENSABLE_APPLY_CONING") eq 'Y'>
               AND  SB_APPLY_CONING = 'Y'
           </cfif>
           AND  SB_CONING_FIN_CLASS_VALID = 'C' and (1 = 2
                <cfoutput query="CompItem">
                    <cfif CompItem.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#CompItem.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#CompItem.SB_MBS_ITEM_NUMBER#' and '#CompItem.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
    </cfquery>

    <cfoutput query="Compensable">

        <cfset VARIABLES.ERROR_TEXT = #Compensable.SB_CONING_ERROR# & " Unable to raise AMA diagnostic accounts for compensable patients">
        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

        <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Comp_error">
            UPDATE SB_CONING_RUN
                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
            WHERE
                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#Compensable.SB_CONING_ID#">
        </cfquery>
    </cfoutput>
</cfif>

<!--- Update Invoice Item with the price by decided by the coning procedures .......  --->

<!--- The SQL command Round(x, decimal places) is equivalent to cf Fix()
Any costs are assumed to be GST exclusive.
If GST inclusive, use the following instead:
        SB_INVOICE_COST = ISNULL(SB_ACTUAL_FEE, 0),
        SB_GST_AMOUNT_CLAIMED = ISNULL(SB_ACTUAL_FEE, 0) - Round((ISNULL(SB_ACTUAL_FEE, 0) * (100.0 / (SB_GST_PERCENT + 100))),2),



SRT, 10-APR-2008 modified query UPDATE_SB_INVOICE_ITEM to only changes price is there is no invoice date
 --->


<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_SB_INVOICE_ITEM">
    UPDATE SB_INVOICE_ITEM
    SET
        SB_INVOICE_COST     =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            CEILING((ISNULL(SB_ACTUAL_FEE,0) * (SB_GST_PERCENT + 100.0) / 100.0 ) / 0.05) * 0.05
        ELSE
            SB_INVOICE_COST
        END,
        SB_GST_AMOUNT_CLAIMED   =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            ISNULL(SB_ACTUAL_FEE,0) * SB_GST_PERCENT / 100.0
        ELSE
            SB_GST_AMOUNT_CLAIMED
        END,
        SB_OUTPAT_ERROR     = left(SB_CONING_ERROR,300),

        SB_CONING_MESSAGE_TO_HIC    = Left(Case     when SB_CONING_BILL_MECH = 'DV' AND
                                        (SB_CONING_NOT_DUP_SERVICE = 'Y' OR SB_CONING_MULTIPLE_OVERRIDE = 'Y')
                                    then  RIGHT(CONVERT(VARCHAR, SB_CONING_RUN.sb_service_date ),7) + ' ' + SB_CONING_MSG_TO_HIC
                                    else  SB_CONING_MSG_TO_HIC end,50),
        SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
        SB_ITEM_QTY         = SB_CONING_QTY,
        SB_FIN_CLASS_CODE   = SB_CONING_FIN_CLASS,
        SB_ITEM_STATUS_CODE     = Case when SB_CONING_STATUS_CODE = 'ER' then 'ER' else SB_ITEM_STATUS_CODE end,
        SB_INVOICE_COST_75  =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            (
            CASE WHEN SB_SCHEDULE_FEE <> SB_ACTUAL_FEE OR (SB_ACTUAL_FEE_75 IS NULL ) THEN
                CEILING((SB_ACTUAL_FEE * 0.75 ) / 0.05) * 0.05
            ELSE
                SB_ACTUAL_FEE_75
            END
            )
        ELSE
            SB_INVOICE_COST_75
        END,
        SB_INVOICE_ITEM.SB_UPDATED_BY =
            <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
            <cfelse>
                'pbrc-ae:ACL'
            </cfif>,
        SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
        SB_UPDATED_FROM = 'apply_coning_logic UPDATE_SB_INVOICE_ITEM'
    FROM
        SB_CONING_RUN INNER JOIN
        SB_INVOICE_ITEM ON
            SB_CONING_RUN.SB_CONING_ITEM_ID = SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID INNER JOIN
        SB_INVOICE ON
            SB_INVOICE_ITEM.SB_INVOICE_ID = SB_INVOICE.SB_INVOICE_ID
    WHERE
        SB_CONING_RUN.SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
        and SB_CONING_RUN.SB_APPLY_CONING = 'N'
</cfquery>

<cfinvoke component="pbrc-ae.components.item" method="Bulid_Message_To_Medicare" returnvariable="none">
    <cfinvokeargument name="Coning_Run" value="#VARIABLES.unique_id#">
</cfinvoke>


    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DELETE">
     DELETE
     FROM   SB_CONING_RUN
     WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
       and SB_CONING_RUN.SB_APPLY_CONING = 'N'
</cfquery>

<!--- This QUERY will be used throughout this program as a CTE --->
<cfset CONING_RECORDS_QUERY = '
     SELECT
        SB_CONING_ID,
        SB_CONING_RUN_NO,
        SB_ITEM_NUMBER,
        SB_SCHEDULE_FEE,
        SB_ACTUAL_FEE,
        SB_CONING_STATUS_CODE,
        SB_SERVICE_DATE,
        SB_CONING_ITEM_ID,
        SB_ACTUAL_FEE_75,
        SB_CONING_ERROR,
        SB_CONING_PROVIDER,
        SB_CONING_PATIENT_AGE,
        SB_CONING_MSG_TO_HIC,
        SB_CONING_QTY,
        SB_GST_PERCENT,
        SB_APPLY_CONING,
        SB_CONING_SPECIALTY_CODE,
        SB_CONING_HOSP_CODE,
        SB_CONING_FIN_CLASS,
        SB_CONING_BILL_MECH,
        SB_CONING_EPISODE,
        SB_REQUEST_DATE,
        SB_CONING_ITEM_TYPE,
        SB_CONING_REQUEST_PROVIDER,
        SB_CONING_CHART_OF_ACC_ID,
        SB_CONING_NOT_DUP_SERVICE,
        SB_CONING_MULTIPLE_OVERRIDE,
        SB_CONING_ADMIT_DATE,
        SB_CONING_DISCH_DATE,
        SB_CONING_INVOICE_ID,
        SB_CONING_REQ_PROV_START,
        SB_CONING_REQ_PROV_END,
        SB_CONING_FIN_CLASS_VALID,
        SB_CONING_HOSP_VALID,
        SB_CONING_SPEC_PROV_DEFINED,
        SB_SERV_PROV_VALID,
        SB_CONING_LSPN,
        SB_CONING_FUND_GROUP_ID,
        SB_CONING_REQUIREMENT_CODE,
        SB_DERIVED_NOGAP_PERCENT,
        SB_CONING_REFERRAL_OVERRIDE,
        SB_CONING_DURATION,
        SB_MBS_100_COST,
        SB_PRIV_BILLING_END_DATE,
        SB_CONING_FIN_CLASS_TYPE_CODE,
        SB_CONING_DEFENCE,
        CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) AS SERVICE_DAY
     FROM
        SB_CONING_RUN
     WHERE
        SB_CONING_RUN_NO = ''' & #VARIABLES.unique_id# & ''''
>

<!--- This QUERY will be used throughout this program to reduce the number of queries against the database
    It will be used as a QUERY of QUERY
--->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DATE_RANGE">
    SET DATEFORMAT DMY
    SELECT
        DISTINCT CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) AS SERVICE_DAY
    FROM
        SB_CONING_RUN
    WHERE
        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
    ORDER BY
        SERVICE_DAY
 </cfquery>
   <!--- This QUERY will be used throughout this program to reduce the number of queries against the database
        It will be used as a QUERY of QUERY
   --->
 <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="PROVIDER_RANGE">
    SET DATEFORMAT DMY
    SELECT
        DISTINCT SB_CONING_PROVIDER
    FROM
        SB_CONING_RUN
    WHERE
        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
    ORDER BY SB_CONING_PROVIDER
 </cfquery>

<!--- Start of Coning Rules --->

<!--- Check to see if the item number already exists for the selected date and time on the invoice item.
This is OK if there is HIOC text, a dup service, or mult proc override set. --->

<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="check_dup_proc">
    SET DATEFORMAT DMY;
    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
</cfquery>

<cfif check_dup_proc.RECORDCOUNT NEQ 0>
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Dup_Proc">
        SELECT
            Min(SB_CONING_ID) as dup_1,
            Max(SB_CONING_ID) as dup_2
        FROM
            SB_CONING_RUN
        WHERE   SB_CONING_NOT_DUP_SERVICE   = 'N'
          AND   SB_CONING_MULTIPLE_OVERRIDE = 'N'
          AND   SB_CONING_REQUIREMENT_CODE = 'N/A'
          AND   SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
        GROUP BY SB_ITEM_NUMBER,
                 SB_SERVICE_DATE
        HAVING COUNT(*) > 1
    </cfquery>
    <cfif Dup_Proc.recordcount gt 0>
        <!--- Loop through the DUP_PROC record set. --->
        <cfloop query="Dup_Proc">
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Dup_error_text">
                UPDATE SB_CONING_RUN
                    SET SB_ACTUAL_FEE = 0,
                        SB_CONING_STATUS_CODE = 'ER',
                        SB_CONING_ERROR = 'Item already exists for the specified date and time. If correct please enter another time, select duplicate service, multiple override or add a requirement code.'
                WHERE
                    SB_CONING_ID in (#Dup_Proc.dup_1#,#Dup_Proc.dup_1#)
            </cfquery>
        </cfloop>
    </cfif>
</cfif>

<!---
    Check to see which coning rules are required.
    SRT, 14-JUL-2006, reformatted query
--->

<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_Coning">
    SET DATEFORMAT DMY
    select distinct
        SB_CONING_RULE.SB_RULE_CODE,
        SB_CONING_RULE.SB_CONING_RULE_ID,
        CONVERT(DATETIME, CONVERT(VARCHAR, sb_coning_run.SB_SERVICE_DATE,103)) AS SERVICE_DAY
    from
        SB_CONING_RULE with (nolock) LEFT OUTER JOIN
        SB_CONING_RULE_ITEM with (nolock) on
            SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID LEFT OUTER JOIN
        sb_coning_run  on
            sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE.SB_MBS_ITEM_NUMBER
            or sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
            or sb_coning_run.SB_ITEM_NUMBER between SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                            and SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
            or
            (SB_CONING_RULE.SB_RULE_CODE = 'OUTP' and (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM' ))
    where
        SB_CONING_RUN.SB_SERVICE_DATE between SB_RULE_START_DATE    and IsNull(SB_RULE_END_DATE,'31-dec-3000')
      and SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
</cfquery>
<!--- Establish a list of required coning rules --->
<cfset required_rules = valuelist(Find_Coning.SB_RULE_CODE)>

<!--- PAE-2263: -Kieran Wood
      Implementation of DIQ and DIQ1 outpatient serverices rules.
      Must be charged at a different rate if bulk billed.
      This is put for the case where there is a single outpatient service on its own,
      in which case DRC and DIAGI combinaion rules would not run on it.--->
<cfif ListFind(required_rules,'DIQ') gt 0 or ListFind(required_rules,'DIQ1') gt 0>
    <!--- get each item in the coning run, and check each one to find the ones that belong in DIQ and DIQ1 rules. --->
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="get_coning_runs">
        SET DATEFORMAT DMY
        select distinct
            SB_CONING_ID, SB_CONING_BILL_MECH, SB_MBS_100_COST
        from
            sb_coning_run
        where
          SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
    </cfquery>

    <cfloop query="get_coning_runs">
        <!--- gets the rules required for this individual item. --->
        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_item_coning">
            SET DATEFORMAT DMY
            select distinct
                SB_CONING_RULE.SB_RULE_CODE,
                SB_CONING_RULE.SB_CONING_RULE_ID,
                CONVERT(DATETIME, CONVERT(VARCHAR, sb_coning_run.SB_SERVICE_DATE,103)) AS SERVICE_DAY
            from
                SB_CONING_RULE with (nolock) INNER JOIN
                SB_CONING_RULE_ITEM with (nolock) on
                    SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID INNER JOIN
                sb_coning_run  on
                    sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE.SB_MBS_ITEM_NUMBER
                    or sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                    or sb_coning_run.SB_ITEM_NUMBER between SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                                    and SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    or
                    (SB_CONING_RULE.SB_RULE_CODE = 'OUTP' and (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM' ))
            where
                SB_CONING_RUN.SB_SERVICE_DATE between SB_RULE_START_DATE    and IsNull(SB_RULE_END_DATE,'31-dec-3000')
              and SB_CONING_ID = '#get_coning_runs.SB_CONING_ID#'
        </cfquery>
        <cfset this_items_rules = valuelist(Find_item_coning.SB_RULE_CODE)>
        <!--- DIQ or DIQ1 required for this rule. --->
        <cfif ListFind(this_items_rules,'DIQ') gt 0 or ListFind(this_items_rules,'DIQ1') gt 0>
            <cfif get_coning_runs.SB_CONING_BILL_MECH eq 'B'
               or get_coning_runs.SB_CONING_BILL_MECH eq 'BM'>
                <!--- set the reduction amount --->
                <cfif ListFind(this_items_rules,'DIQ') gt 0>
                    <cfset reduction_percent = 0.95>
                    <cfset rule_used = 'DIQ'>
                <cfelseif ListFind(this_items_rules,'DIQ1') gt 0>
                    <cfset reduction_percent = 1>
                    <cfset rule_used = 'DIQ1'>
                </cfif>

                <!--- now update the actual fee to have the correct cost for this item. --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                    UPDATE SB_CONING_RUN
                        SET SB_ACTUAL_FEE = CEILING(#get_coning_runs.SB_MBS_100_COST# * #reduction_percent# / 0.05 ) * 0.05,
                            CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#rule_used#') <= 100
                                                    THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#rule_used#' ELSE '#rule_used#' END)
                                                    ELSE CONING_RULES_APPLIED END
                    WHERE
                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#get_coning_runs.SB_CONING_ID#">
                </cfquery>

            </cfif>
        </cfif>
    </cfloop>
</cfif>



 <!--- Start of Multiple Operations Forumala

 For multiple operations (MBS items 30001 to 51318) that is not an amputation (44325 - 44376) performed by the
 same dr on the same day , the most expensive is to be 100% of cost, 2nd most expensive is to be 50%,
 and subsequent operations charged at 25%.

 Assume all items are on the one invoice

  --->

<cfif ListFind(required_rules,'MOP') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'MOP'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>
            <!--- Multiple Operations means more than one record in MULTIPLE_OPERATIONS.
            Tables are accessed as query of queries.
             --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MOP">
                select  SB_RULE_PERCENT1,
                        SB_RULE_PERCENT2,
                        SB_RULE_PERCENT3,
                        SB_CONING_RULE_ID
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MOPITEM">
                select  SB_MBS_ITEM_NUMBER,
                        SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM  with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif mopitem.recordcount eq 0>
                The coning run requires the MOP (multiple operations) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="AMPITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'AMP'
            </cfquery>
            <cfif ampitem.recordcount eq 0>
                The coning run requires the AMP (amputation operations) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_OPERATIONS">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SERVICE_DAY,
                    SB_CONING_PROVIDER
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    SB_CONING_MULTIPLE_OVERRIDE = 'N' and
                    (1 = 2
                <cfoutput query="MOPITEM">
                    <cfif MOPITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#MOPITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#MOPITEM.SB_MBS_ITEM_NUMBER#' and '#MOPITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                <cfoutput query="AMPITEM">
                    <cfif AMPITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        and SB_ITEM_NUMBER <> '#AMPITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        and SB_ITEM_NUMBER NOT BETWEEN '#AMPITEM.SB_MBS_ITEM_NUMBER#' and '#AMPITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>

                ORDER BY
                    SERVICE_DAY,
                    SB_CONING_PROVIDER,
                    SB_SCHEDULE_FEE DESC,
                    SB_ITEM_NUMBER ASC,
                    SB_ACTUAL_FEE DESC
            </cfquery>

            <cfif MULTIPLE_OPERATIONS.recordcount gt 0>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">

                <!--- Loop through the MULTIPLE_OPERATIONS record set. --->
                <cfloop query="MULTIPLE_OPERATIONS">

                    <!--- For the first record, the SERVICE_DATE and  PROVIDER VARIABLES will be blank
                        The second and following records may be on the same date with same provider
                    --->
                    <cfif APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE) EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(MULTIPLE_OPERATIONS.SERVICE_DAY)
                        AND VARIABLES.PROVIDER EQ MULTIPLE_OPERATIONS.SB_CONING_PROVIDER>

                        <!--- A second or subsequent record has been processed for the same day and provider --->
                        <cfset VARIABLES.item_count = VARIABLES.item_count + 1>

                        <cfif VARIABLES.item_count eq 1>
                            <cfset VARIABLES.reduced_rate = MOP.SB_RULE_PERCENT1 / 100>
                        <cfelseif VARIABLES.item_count eq 2>
                            <cfset VARIABLES.reduced_rate = MOP.SB_RULE_PERCENT2 / 100>
                        <cfelse>
                            <cfset VARIABLES.reduced_rate = MOP.SB_RULE_PERCENT3 / 100>
                        </cfif>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                            UPDATE SB_CONING_RUN
                                SET SB_ACTUAL_FEE = CEILING((ISNULL(SB_ACTUAL_FEE, 0) * #VARIABLES.reduced_rate#) / 0.05) * 0.05,
                                    CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'MOP') <= 100
                                                            THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'MOP' ELSE 'MOP' END)
                                                            ELSE CONING_RULES_APPLIED END
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MULTIPLE_OPERATIONS.SB_CONING_ID#">
                        </cfquery>
                    <cfelse>
                        <!---  A record with a different date and provider has been processed  --->
                        <cfset VARIABLES.item_count = 1>
                        <!--- Update the service date and provider VARIABLES--->
                        <cfset VARIABLES.SB_CONING_ID = MULTIPLE_OPERATIONS.SB_CONING_ID>
                        <cfset VARIABLES.SERVICE_DATE = MULTIPLE_OPERATIONS.SERVICE_DAY>
                        <cfset VARIABLES.PROVIDER = MULTIPLE_OPERATIONS.SB_CONING_PROVIDER>
                    </cfif>

                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>


<!--- End Of Multiple Operations Forumala --->

<!--- Start of Diagnostic Rule A

Where there are two or more diagnostic imaging services (55028 to 63946) by the same dr on the same day,
then the higher schedule amount is unchanged, and any others are reduced by $5.00

Medicare do this in a very bizarre fashion. For bulk bill, the $5 should become $4.25 (85% of 5).
However, some mbs 85% list prices are not exactly 85% of the schedule fee. In these cases,
medicare take 100%, then subtract $5, then multiply by 85%
This is not the same as the 85% list price, less $4.25
Hence for bulk bill, find 100% cost, subtract the 5, multiply by .85 and round up / down to
nearest 5 cents.

 --->
<cfif ListFind(required_rules,'DIAGI') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'DIAGI'>

            <!---
                Generates the list of coning id's on this run that relate to items on invoices which contain any non-VULT items.
                You would expect this to be the case most of the time, so this would usually contain all the coning id's in this run.
                However, items on invoices with ONLY VULT items should not receive the -5 dollar DRA reduction further down in the code,
                so this helps us later, where we can make sure to only apply the -5 dollar reduction to the items on this list.
            --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="VULT_CHECK">
               WITH vult
                     AS (SELECT c_item.sb_mbs_item_number,
                                c_item.sb_mbs_item_number_to,
                                c_rule.sb_coning_rule_id
                         FROM   sb_coning_rule_item c_item
                                INNER JOIN sb_coning_rule c_rule
                                        ON c_rule.sb_coning_rule_id = c_item.sb_coning_rule_id
                                           AND c_rule.sb_rule_code = 'VULT')

                SELECT DISTINCT sb_coning_id,
                                item.*
                FROM   sb_coning_run cr
                       INNER JOIN sb_invoice_item item
                               ON cr.sb_coning_item_id = item.sb_invoice_item_id
                       LEFT OUTER JOIN sb_invoice_item item2
                                    ON item2.sb_invoice_id = item.sb_invoice_id
                       LEFT OUTER JOIN vult
                                    ON vult.sb_mbs_item_number = item2.sb_mbs_item_number
                                        OR item2.sb_mbs_item_number BETWEEN
                                           vult.sb_mbs_item_number AND
                                           vult.sb_mbs_item_number_to
                       LEFT OUTER JOIN sb_coning_rule c_rule
                                    ON c_rule.sb_coning_rule_id = vult.sb_coning_rule_id
                                       AND c_rule.sb_rule_code = 'VULT'
                WHERE  cr.sb_coning_run_no = '#VARIABLES.unique_id#'
                       AND c_rule.sb_coning_rule_id IS NULL
            </cfquery>

            <!---
                Invoices with only MMUS items should also not have -5 dollar DRA reduction applied, so this is selected for in the same way as VULT_CHECK above.
            --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MMUS_CHECK">
                WITH mmus
                     AS (SELECT c_item.sb_mbs_item_number,
                                c_item.sb_mbs_item_number_to,
                                c_rule.sb_coning_rule_id
                         FROM   sb_coning_rule_item c_item
                                INNER JOIN sb_coning_rule c_rule
                                        ON c_rule.sb_coning_rule_id = c_item.sb_coning_rule_id
                                           AND c_rule.sb_rule_code = 'MMUS')

                SELECT DISTINCT sb_coning_id,
                                item.*
                FROM   sb_coning_run cr
                       INNER JOIN sb_invoice_item item
                               ON cr.sb_coning_item_id = item.sb_invoice_item_id
                       LEFT OUTER JOIN sb_invoice_item item2
                                    ON item2.sb_invoice_id = item.sb_invoice_id
                       LEFT OUTER JOIN mmus
                                    ON mmus.sb_mbs_item_number = item2.sb_mbs_item_number
                                        OR item2.sb_mbs_item_number BETWEEN
                                           mmus.sb_mbs_item_number AND
                                           mmus.sb_mbs_item_number_to
                       LEFT OUTER JOIN sb_coning_rule c_rule
                                    ON c_rule.sb_coning_rule_id = mmus.sb_coning_rule_id
                                       AND c_rule.sb_rule_code = 'MMUS'
                WHERE  cr.sb_coning_run_no = '#VARIABLES.unique_id#'
                       AND c_rule.sb_coning_rule_id IS NULL
            </cfquery>

            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DRA">
                select  SB_REDUCE_SUB_BY
                from    SB_CONING_RULE with (nolock)
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_RULE_CODE = 'DRA'
            </cfquery>
            <cfif DRA.recordcount eq 0>
                The coning run requires the DRA (Diagnostic Rule A) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGIITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE.SB_CONING_RULE_ID = #this_rule_id#
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
            </cfquery>
            <cfif DIAGIITEM.recordcount eq 0>
                The coning run requires the DIAGI (Diagnostic Imaging Definition) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_A">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_SERVICE_DATE,
                    SERVICE_DAY,
                    SB_CONING_PROVIDER,
                    SB_CONING_BILL_MECH,
                    SB_ACTUAL_FEE,
                    SB_MBS_100_COST
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="DIAGIITEM">
                    <cfif DIAGIITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#DIAGIITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#DIAGIITEM.SB_MBS_ITEM_NUMBER#' and '#DIAGIITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                ORDER BY
                    SERVICE_DAY,
                    SB_CONING_PROVIDER,
                    SB_SCHEDULE_FEE DESC,
                    SB_ACTUAL_FEE DESC
            </cfquery>

            <!--- Two or more diagnostic imaging services --->
            <cfif DIAGNOSTIC_RULE_A.recordcount GTE 2>

                <cfset VARIABLES.SB_CONING_ID = "">
                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">

                <!--- Loop through the DIAGNOSTIC_RULE_A record set. --->
                <cfloop query="DIAGNOSTIC_RULE_A">
                    <!--- For the first record, the SERVICE_DATE and  PROVIDER VARIABLES will be blank
                        The second and following records may be on the same date with same provider
                    --->
                    <cfif APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE) EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(DIAGNOSTIC_RULE_A.SERVICE_DAY)
                        AND VARIABLES.PROVIDER EQ DIAGNOSTIC_RULE_A.SB_CONING_PROVIDER>

                        <!--- A second or subsequent record has been processed for the same day and provider --->
                        <cfset VARIABLES.item_count = VARIABLES.item_count + 1>

                        <cfif VARIABLES.item_count GT 1>
            <!---           For bulk bill, reduction is 85% of normal reduction --->
                            <cfif DIAGNOSTIC_RULE_A.SB_CONING_BILL_MECH eq 'B'
                               or DIAGNOSTIC_RULE_A.SB_CONING_BILL_MECH eq 'BM'>

                               <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_item_coning">
                                    SET DATEFORMAT DMY
                                    select distinct
                                        SB_CONING_RULE.SB_RULE_CODE,
                                        SB_CONING_RULE.SB_CONING_RULE_ID,
                                        CONVERT(DATETIME, CONVERT(VARCHAR, sb_coning_run.SB_SERVICE_DATE,103)) AS SERVICE_DAY
                                    from
                                        SB_CONING_RULE with (nolock) INNER JOIN
                                        SB_CONING_RULE_ITEM with (nolock) on
                                            SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID INNER JOIN
                                        sb_coning_run  on
                                            sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE.SB_MBS_ITEM_NUMBER
                                            or sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                            or sb_coning_run.SB_ITEM_NUMBER between SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                                                            and SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                                            or
                                            (SB_CONING_RULE.SB_RULE_CODE = 'OUTP' and (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM' ))
                                    where
                                        SB_CONING_RUN.SB_SERVICE_DATE between SB_RULE_START_DATE    and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                                      and SB_CONING_ID = '#DIAGNOSTIC_RULE_A.SB_CONING_ID#'
                                </cfquery>
                               <cfset this_items_rules = valuelist(Find_item_coning.SB_RULE_CODE)>

                               <cfif ListFind(this_items_rules,'DIQ') gt 0>
                                    <cfset reduction_percent = 0.95>
                                <cfelseif ListFind(this_items_rules,'DIQ1') gt 0>
                                    <cfset reduction_percent = 1>
                                <cfelse>
                                    <cfset reduction_percent = 0.85>
                                </cfif>
                               <cfset item_cost = DIAGNOSTIC_RULE_A.SB_MBS_100_COST>
                            <cfelse>
                               <cfset reduction_percent = 1>
                               <cfset item_cost = DIAGNOSTIC_RULE_A.SB_ACTUAL_FEE>
                            </cfif>

                            <!--- The -5 dollar DRA reduction does not apply to invoices that contain only VULT items or to invoices that contain only MMUS items --->
                            <cfset VULT_LIST = ValueList(VULT_CHECK.SB_CONING_ID)>
                            <cfset MMUS_LIST = ValueList(MMUS_CHECK.SB_CONING_ID)>
                            <cfif ListFind(VULT_LIST, DIAGNOSTIC_RULE_A.SB_CONING_ID) eq 0 or ListFind(MMUS_LIST, DIAGNOSTIC_RULE_A.SB_CONING_ID) eq 0>
                                <cfset VARIABLES.reduced_rate = 0>
                            <cfelse>
                                <cfset VARIABLES.reduced_rate = DRA.SB_REDUCE_SUB_BY>
                            </cfif>

<!---
Phil : 30-Oct-2007
Had a problem with item 57715,
where select Round((60.9 - 5) * .85 / 5,2) * 5 gives 47.50
but medicare pay 47.55
If you ignore rounding to nearest 5 cents, it is 47.515
I assume medicare are rounding up to nearest 5 cents.
Therefore changed formula to be
select ceiling((60.9 - 5) * .85 * 100 / 5) * 5 / 100
which give 47.55
Changed
    SET SB_ACTUAL_FEE = Round((#item_cost# - #VARIABLES.reduced_rate#) * #reduction_percent# / 5,2) * 5
to be
    SET SB_ACTUAL_FEE = ceiling((#item_cost# - #VARIABLES.reduced_rate#) * #reduction_percent# * 100 / 5) * 5 / 100
 --->

                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                                UPDATE SB_CONING_RUN
                                    SET SB_ACTUAL_FEE = ceiling((#item_cost# - #VARIABLES.reduced_rate# - CURRENT_DEDUCTIONS) * #reduction_percent# * 100 / 5) * 5 / 100,
                                        CURRENT_DEDUCTIONS = CURRENT_DEDUCTIONS + #VARIABLES.reduced_rate#,
                                        CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'DRA') <= 100
                                                                THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'DRA' ELSE 'DRA' END)
                                                                ELSE CONING_RULES_APPLIED END
                                WHERE
                                    SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#DIAGNOSTIC_RULE_A.SB_CONING_ID#">
                            </cfquery>
                        </cfif>

                    <cfelse>
                        <!---  A record with a different date and provider has been processed  --->
                        <cfset VARIABLES.item_count = 1>
                        <!--- Update the service date and provider VARIABLES--->
                        <cfset VARIABLES.SB_CONING_ID = DIAGNOSTIC_RULE_A.SB_CONING_ID>
                        <cfset VARIABLES.SERVICE_DATE = DIAGNOSTIC_RULE_A.SERVICE_DAY>
                        <cfset VARIABLES.PROVIDER = DIAGNOSTIC_RULE_A.SB_CONING_PROVIDER>
                    </cfif>

                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>
<!--- End of Diagnostic Rule A --->
<!--- Start of Diagnostic Rule B

Where there is at least one R_Type service (see list below), and at least one consultation (00001 through 10816)
by the same dr on the same day, then the highest charged R-Type service only is reduced as follows:
if schedule fee >= 40, then reduce by 35
if schedule fee <40 and > 15 reduce by 15
if schedule fee <= 15 reduce to zero.

R-Type diagnostic services are as follows :
55029,55031,55033,55037,55039,55045, 55049,55073, 55079,55703,55705, 55709, 55715,
55723, 55725,55733,55739,55762,55766, 55770,55774,55802,55806,55810,55814,55818,55822,55826,55830,55834,
55838,55842,55846, 55854,57506,57512,57518,57524,57700,57706,58500,58900,60072,60075,60078,60918,60927

 --->
<cfif ListFind(required_rules,'CONS') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'CONS'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DRB">
                select  SB_CONSULT_FEE_1,
                    SB_REDUCTION_1,
                    SB_CONSULT_FEE_2,
                    SB_REDUCTION_2
                from    SB_CONING_RULE with (nolock)
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_RULE_CODE = 'DRB'
            </cfquery>
            <cfif DRB.recordcount eq 0>
                The coning run requires the DRB (Diagnostic Rule B) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CONSITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE.SB_CONING_RULE_ID = #this_rule_id#
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
            </cfquery>
            <cfif CONSITEM.recordcount eq 0>
                The coning run requires the CONS (Consultation Item Definition) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="RTYPEITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'RTYPE'
            </cfquery>
            <cfif RTYPEITEM.recordcount eq 0>
                The coning run requires the RTYPE (RType Item Definition) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_B_R_TYPE">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    COUNT(SB_CONING_ID) AS R_TYPE
                FROM
                    CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="RTYPEITEM">
                    <cfif RTYPEITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#RTYPEITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#RTYPEITEM.SB_MBS_ITEM_NUMBER#' and '#RTYPEITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_B_CONSULTATION">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT          COUNT(SB_CONING_ID) AS CONSULTATION
                FROM            CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="CONSITEM">
                    <cfif CONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#CONSITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#CONSITEM.SB_MBS_ITEM_NUMBER#' and '#CONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfif DIAGNOSTIC_RULE_B_R_TYPE.R_TYPE GT 0 AND DIAGNOSTIC_RULE_B_CONSULTATION.CONSULTATION GT 0>
            <!--- Originally tried this as query of query, but it couldn't handle the case in the select statement --->
                <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_B_COMBINED">
                    SET DATEFORMAT DMY
                    SELECT
                        SB_MBS_100_COST,
                        SB_CONING_ID,
                        SB_ITEM_NUMBER,
                        CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) AS SERVICE_DAY,
                        SB_CONING_PROVIDER,
                        SB_ACTUAL_FEE,
                        SB_SCHEDULE_FEE,
                        CASE
                            when  1 = 2
                        <cfoutput query="CONSITEM">
                            <cfif CONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#CONSITEM.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#CONSITEM.SB_MBS_ITEM_NUMBER#' and '#CONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                            then 0
                            else 1
                        end as consult_item,
                        SB_CONING_BILL_MECH
                    FROM
                        SB_CONING_RUN
                WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                AND CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day#' and
                (   1 = 2
                <cfoutput query="RTYPEITEM">
                    <cfif RTYPEITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#RTYPEITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#RTYPEITEM.SB_MBS_ITEM_NUMBER#' and '#RTYPEITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                <cfoutput query="CONSITEM">
                    <cfif CONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#CONSITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#CONSITEM.SB_MBS_ITEM_NUMBER#' and '#CONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                )
                        ORDER BY CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)),
                                 SB_CONING_PROVIDER,
                                 consult_item,
                                 SB_SCHEDULE_FEE DESC,
                                 SB_ACTUAL_FEE DESC
                </cfquery>

                <!--- Two or more diagnostic imaging services --->
                <cfif DIAGNOSTIC_RULE_B_COMBINED.recordcount GTE 2>

                    <cfset VARIABLES.SERVICE_DATE = "">
                    <cfset VARIABLES.PROVIDER = "">
                    <cfset consult_sched_fee = "">

                    <!--- Loop through the DIAGNOSTIC_RULE_A record set. --->
                    <cfloop query="DIAGNOSTIC_RULE_B_COMBINED">

                        <!--- Each time the day and provider changes, insert that record (in addition to the first record .. which has the highest fee)--->

                        <cfif APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE) NEQ APPLICATION.dateFunctions.parseDateTimeWithNULL(DIAGNOSTIC_RULE_B_COMBINED.SERVICE_DAY)
                           OR VARIABLES.PROVIDER NEQ DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_PROVIDER>

                            <cfset VARIABLES.SERVICE_DATE = DIAGNOSTIC_RULE_B_COMBINED.SERVICE_DAY>
                            <cfset VARIABLES.PROVIDER = DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_PROVIDER>
                            <cfset consult_sched_fee = "">

                        <!--- If first consult item for the day, the store the sched fee amount --->
                            <cfif DIAGNOSTIC_RULE_B_COMBINED.consult_item eq 0 and consult_sched_fee eq "">
                                <cfset consult_sched_fee = DIAGNOSTIC_RULE_B_COMBINED.SB_MBS_100_COST>
                            </cfif>
                        <cfelse>
                            <!--- same day - if first diag item then update --->
                            <cfif DIAGNOSTIC_RULE_B_COMBINED.consult_item eq 1 and consult_sched_fee neq "">

                                <!---   For bulk bill, reduction is 85% of normal reduction --->
                                <cfif DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_BILL_MECH eq 'B'
                                   or DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_BILL_MECH eq 'BM'>

                                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_item_coning">
                                        SET DATEFORMAT DMY
                                        select distinct
                                            SB_CONING_RULE.SB_RULE_CODE,
                                            SB_CONING_RULE.SB_CONING_RULE_ID,
                                            CONVERT(DATETIME, CONVERT(VARCHAR, sb_coning_run.SB_SERVICE_DATE,103)) AS SERVICE_DAY
                                        from
                                            SB_CONING_RULE with (nolock) INNER JOIN
                                            SB_CONING_RULE_ITEM with (nolock) on
                                                SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID INNER JOIN
                                            sb_coning_run  on
                                                sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE.SB_MBS_ITEM_NUMBER
                                                or sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                                or sb_coning_run.SB_ITEM_NUMBER between SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                                                                and SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                                                or
                                                (SB_CONING_RULE.SB_RULE_CODE = 'OUTP' and (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM' ))
                                        where
                                            SB_CONING_RUN.SB_SERVICE_DATE between SB_RULE_START_DATE    and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                                          and SB_CONING_ID = '#DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_ID#'
                                    </cfquery>

                                    <cfset this_items_rules = valuelist(Find_item_coning.SB_RULE_CODE)>

                                    <cfif ListFind(this_items_rules,'DIQ') gt 0>
                                        <cfset reduction_percent = 0.95>
                                    <cfelseif ListFind(this_items_rules,'DIQ1') gt 0>
                                        <cfset reduction_percent = 1>
                                    <cfelse>
                                        <cfset reduction_percent = 0.85>
                                    </cfif>

                                <cfelse>
                                   <cfset reduction_percent = 1>
                                </cfif>

                                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                                    UPDATE SB_CONING_RUN
                                        SET SB_ACTUAL_FEE = CASE WHEN #consult_sched_fee# >= #drb.SB_CONSULT_FEE_1# THEN
                                                                     CEILING(((#DIAGNOSTIC_RULE_B_COMBINED.SB_MBS_100_COST# - #drb.SB_REDUCTION_1# - CURRENT_DEDUCTIONS) * #reduction_percent#) / 0.05) * 0.05
                                                                 WHEN #consult_sched_fee# > #drb.SB_CONSULT_FEE_2#  THEN
                                                                     CEILING(((#DIAGNOSTIC_RULE_B_COMBINED.SB_MBS_100_COST# - #drb.SB_REDUCTION_2# - CURRENT_DEDUCTIONS) * #reduction_percent#) / 0.05) * 0.05
                                                                 ELSE
                                                                     CEILING(((#DIAGNOSTIC_RULE_B_COMBINED.SB_MBS_100_COST# - #consult_sched_fee# - CURRENT_DEDUCTIONS) * #reduction_percent#) / 0.05) * 0.05
                                                            END,
                                            CURRENT_DEDUCTIONS = CURRENT_DEDUCTIONS +
                                                            CASE WHEN #consult_sched_fee# >= #drb.SB_CONSULT_FEE_1# THEN
                                                                     #drb.SB_REDUCTION_1#
                                                                 WHEN #consult_sched_fee# > #drb.SB_CONSULT_FEE_2#  THEN
                                                                     #drb.SB_REDUCTION_2#
                                                                 ELSE
                                                                     #consult_sched_fee#
                                                            END,
                                            CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'DRB') <= 100
                                                                    THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'DRB' ELSE 'DRB' END)
                                                                    ELSE CONING_RULES_APPLIED END
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#DIAGNOSTIC_RULE_B_COMBINED.SB_CONING_ID#">
                                </cfquery>
                            <cfset consult_sched_fee = "">
                            </cfif>
                        </cfif>


                    </cfloop>
                </cfif>
            </cfif>
        </cfif>
    </cfloop>
</cfif>
<!--- End of Diagnostic Rule B --->

<!--- Start of Diagnostic Rule C

Where there is at least one R_Type service (see list below), and at least one non consultation
by the same dr on the same day, then the highest charged R-Type service only is reduced by $5.00

R-Type diagnostic services are as follows :
55029,55031,55033,55037,55039,55045, 55049,55073, 55079,55703,55705, 55709, 55715,
55723, 55725,55733,55739,55762,55766, 55770,55774,55802,55806,55810,55814,55818,55822,55826,55830,55834,
55838,55842,55846, 55854,57506,57512,57518,57524,57700,57706,58500,58900,60072,60075,60078,60918,60927

 --->

<cfif ListFind(required_rules,'DRC') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'DRC'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DRC">
                select  SB_REDUCTION_1
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE.SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif DRC.recordcount eq 0>
                The coning run requires the DRC (Diagnostic Rule C) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="NCONSITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE.SB_CONING_RULE_ID = #this_rule_id#
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
            </cfquery>
            <cfif NCONSITEM.recordcount eq 0>
                The coning run requires the DRC (Diagnostic Rule C) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="RTYPEITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock),
                        SB_CONING_RULE with (nolock)
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'RTYPE'
            </cfquery>
            <cfif RTYPEITEM.recordcount eq 0>
                The coning run requires the RTYPE (RType Item Definition) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_C_R_TYPE">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    COUNT(SB_CONING_ID) AS R_TYPE
                FROM
                    CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="RTYPEITEM">
                    <cfif RTYPEITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#RTYPEITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#RTYPEITEM.SB_MBS_ITEM_NUMBER#' and '#RTYPEITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_C_CONSULTATION">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT          COUNT(SB_CONING_ID) AS NONCONSULTATION
                FROM            CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="NCONSITEM">
                    <cfif NCONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#NCONSITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#NCONSITEM.SB_MBS_ITEM_NUMBER#' and '#NCONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfif DIAGNOSTIC_RULE_C_R_TYPE.R_TYPE GT 0 AND DIAGNOSTIC_RULE_C_CONSULTATION.NONCONSULTATION GT 0>
            <!--- Originally tried this as query of query, but it couldn't handle the case in the select statement --->
                <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RULE_C_COMBINED">
                    SET DATEFORMAT DMY
                    SELECT
                        SB_MBS_100_COST,
                        SB_CONING_ID,
                        SB_ITEM_NUMBER,
                        CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) AS SERVICE_DAY,
                        SB_CONING_PROVIDER,
                        SB_ACTUAL_FEE,
                        CASE
                            when  1 = 2
                        <cfoutput query="NCONSITEM">
                            <cfif NCONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#NCONSITEM.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#NCONSITEM.SB_MBS_ITEM_NUMBER#' and '#NCONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                            then 0
                            else 1
                        end as nonconsult_item,
                        SB_CONING_BILL_MECH
                    FROM
                        SB_CONING_RUN
                WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                and CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day_MMM#'
                AND (   1 = 2
                <cfoutput query="RTYPEITEM">
                    <cfif RTYPEITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#RTYPEITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#RTYPEITEM.SB_MBS_ITEM_NUMBER#' and '#RTYPEITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                <cfoutput query="NCONSITEM">
                    <cfif NCONSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#NCONSITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#NCONSITEM.SB_MBS_ITEM_NUMBER#' and '#NCONSITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                )
                        ORDER BY CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)),
                                 SB_CONING_PROVIDER,
                                 nonconsult_item,
                                 SB_SCHEDULE_FEE DESC,
                                 SB_ACTUAL_FEE DESC
                </cfquery>

                <!--- Two or more diagnostic imaging services --->
                <cfif DIAGNOSTIC_RULE_C_COMBINED.recordcount GTE 2>

                    <cfset VARIABLES.SERVICE_DATE = "">
                    <cfset VARIABLES.PROVIDER = "">
                    <cfset consult_sched_fee = "">

                    <!--- Loop through the DIAGNOSTIC_RULE_C record set. --->
                    <cfloop query="DIAGNOSTIC_RULE_C_COMBINED">

                        <!--- Each time the day and provider changes, insert that record (in addition to the first record .. which has the highest fee)--->

                        <cfif VARIABLES.SERVICE_DATE eq "">
                            <cfset parsed_date = "">
                        <cfelse>
                            <cfset parsed_date = APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE)>
                        </cfif>

                        <cfif parsed_date NEQ APPLICATION.dateFunctions.parseDateTimeWithNULL(DIAGNOSTIC_RULE_C_COMBINED.SERVICE_DAY)
                           OR VARIABLES.PROVIDER NEQ DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_PROVIDER>

                            <cfset VARIABLES.SERVICE_DATE = DIAGNOSTIC_RULE_C_COMBINED.SERVICE_DAY>
                            <cfset VARIABLES.PROVIDER = DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_PROVIDER>
                            <cfset consult_sched_fee = "">

                        <!--- If first consult item for the day, the store the sched fee amount --->
                            <cfif DIAGNOSTIC_RULE_C_COMBINED.nonconsult_item eq 0 and consult_sched_fee eq "">
                                <cfset consult_sched_fee = DIAGNOSTIC_RULE_C_COMBINED.SB_ACTUAL_FEE>
                            </cfif>
                        <cfelse>

                            <!---   For bulk bill, reduction is 85% of normal reduction --->
                            <cfif DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_BILL_MECH eq 'B'
                               or DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_BILL_MECH eq 'BM'>

                                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Find_item_coning">
                                    SET DATEFORMAT DMY
                                    select distinct
                                        SB_CONING_RULE.SB_RULE_CODE,
                                        SB_CONING_RULE.SB_CONING_RULE_ID,
                                        CONVERT(DATETIME, CONVERT(VARCHAR, sb_coning_run.SB_SERVICE_DATE,103)) AS SERVICE_DAY
                                    from
                                        SB_CONING_RULE with (nolock) INNER JOIN
                                        SB_CONING_RULE_ITEM with (nolock) on
                                            SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID INNER JOIN
                                        sb_coning_run  on
                                            sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE.SB_MBS_ITEM_NUMBER
                                            or sb_coning_run.SB_ITEM_NUMBER = SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                            or sb_coning_run.SB_ITEM_NUMBER between SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                                                                            and SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                                            or
                                            (SB_CONING_RULE.SB_RULE_CODE = 'OUTP' and (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM' ))
                                    where
                                        SB_CONING_RUN.SB_SERVICE_DATE between SB_RULE_START_DATE    and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                                      and SB_CONING_ID = '#DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_ID#'
                                </cfquery>

                                <cfset this_items_rules = valuelist(Find_item_coning.SB_RULE_CODE)>

                                <cfif ListFind(this_items_rules,'DIQ') gt 0>
                                    <cfset reduction_percent = 0.95>
                                <cfelseif ListFind(this_items_rules,'DIQ1') gt 0>
                                    <cfset reduction_percent = 1>
                                <cfelse>
                                    <cfset reduction_percent = 0.85>
                                </cfif>

                            <cfelse>
                               <cfset reduction_percent = 1>
                            </cfif>

                            <!--- same day - if first diag item then update --->
                            <cfif DIAGNOSTIC_RULE_C_COMBINED.nonconsult_item eq 1 and consult_sched_fee neq "">
                                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                                    UPDATE SB_CONING_RUN
                                <cfif DIAGNOSTIC_RULE_C_COMBINED.SB_ACTUAL_FEE gt drc.SB_REDUCTION_1>
                                        SET SB_ACTUAL_FEE = CEILING(((#DIAGNOSTIC_RULE_C_COMBINED.SB_MBS_100_COST# - #drc.SB_REDUCTION_1# - CURRENT_DEDUCTIONS ) * #reduction_percent#) / 0.05) * 0.05,
                                            CURRENT_DEDUCTIONS = CURRENT_DEDUCTIONS + #drc.SB_REDUCTION_1#
                                <cfelse>
                                        SET SB_ACTUAL_FEE = 0
                                </cfif>,
                                        CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'DRC') <= 100
                                                                THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'DRC' ELSE 'DRC' END)
                                                                ELSE CONING_RULES_APPLIED END
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#DIAGNOSTIC_RULE_C_COMBINED.SB_CONING_ID#">
                                </cfquery>
                            <cfset consult_sched_fee = "">
                            </cfif>
                        </cfif>


                    </cfloop>
                </cfif>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

<!--- End of Diagnostic Rule C --->

<!--- Start Of Mutliple Services - ECG

11700 only allowed once every hour
 --->
<cfif ListFind(required_rules,'ECG') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ECG'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ECG">
                select  SB_HOURS_BETWEEN
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ECG.recordcount eq 0>
                The coning run requires the ECG (ECG multiple Service rule) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ECGITEM">
                select  SB_MBS_ITEM_NUMBER,
                        SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ECGITEM.recordcount eq 0>
                The coning run requires the ECG (ECG multiple Service rule) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_ECG">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER,
                    SB_CONING_ERROR
                FROM CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="ECGITEM">
                    <cfif ECGITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ECGITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ECGITEM.SB_MBS_ITEM_NUMBER#' and '#ECGITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                ORDER BY
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER
            </cfquery>

            <!--- If there is more than one ECG service, continue.. --->
            <cfif MULTIPLE_SERVICES_ECG.RECORDCOUNT GT 1>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">
                <cfset VARIABLES.LAST_CONING_ID = "">
                <cfset MINIMUM_MINUTES = 60 * ECG.SB_HOURS_BETWEEN>
                <!--- Loop through each record in MUTLIPLE_SERVICES_ECG --->
                <cfloop query="MULTIPLE_SERVICES_ECG">

                    <!---  For the same provider on the same day --->
                    <cfif (VARIABLES.SERVICE_DATE EQ "" AND VARIABLES.PROVIDER EQ "") OR
                            (APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(VARIABLES.SERVICE_DATE,'YYYY-MM-DD')) EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(dateFormat(MULTIPLE_SERVICES_ECG.SB_SERVICE_DATE,'YYYY-MM-DD')) AND
                             VARIABLES.PROVIDER EQ MULTIPLE_SERVICES_ECG.SB_CONING_PROVIDER)>

                             <cfif MULTIPLE_SERVICES_ECG.CurrentRow eq 1>
                                <!--- This var is the date and time at which the first service has occured --->
                                <cfset VARIABLES.charged_item_time = MULTIPLE_SERVICES_ECG.SB_SERVICE_DATE>
                             </cfif>

                             <!--- If a subsequent ECG occurs less than 1 hours after the charged item, it costs 0 --->
                             <cfif DATEDIFF("N", VARIABLES.charged_item_time, MULTIPLE_SERVICES_ECG.SB_SERVICE_DATE) LT MINIMUM_MINUTES and
                                    MULTIPLE_SERVICES_ECG.CurrentRow neq 1>
                                    <cfset VARIABLES.ERROR_TEXT = #MULTIPLE_SERVICES_ECG.SB_CONING_ERROR# & " Item can only be claimed once every #ECG.SB_HOURS_BETWEEN# hours">

                                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
                                    <!--- Set the error message every record that is not the first in the series for a
                                        item and date --->
                                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_ECG_error_text">
                                        UPDATE SB_CONING_RUN
                                            SET SB_ACTUAL_FEE = 0,
                                                SB_CONING_STATUS_CODE = 'ER',
                                                SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
                                        WHERE
                                            SB_CONING_ID IN (#MULTIPLE_SERVICES_ECG.SB_CONING_ID#, #VARIABLES.LAST_CONING_ID#)
                                    </cfquery>
                             <cfelse>
                                <!--- Update this variable to the date and time at which the last item was charged at` --->
                                 <cfset VARIABLES.charged_item_time = MULTIPLE_SERVICES_ECG.SB_SERVICE_DATE>
                             </cfif>
                    </cfif>

                    <cfset VARIABLES.SERVICE_DATE = MULTIPLE_SERVICES_ECG.SB_SERVICE_DATE>
                    <cfset VARIABLES.PROVIDER = MULTIPLE_SERVICES_ECG.SB_CONING_PROVIDER>
                    <cfset VARIABLES.LAST_CONING_ID = MULTIPLE_SERVICES_ECG.SB_CONING_ID>
                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>

 <!---  End Of Mutliple Services - ECG rule --->
<!--- Start Of Mutliple Services - Ultrasound rule

If an item number in the following ranges has already been entered by the same dr for the same date
they must be 3hrs apart 55113 to 55130, 55238 to 55296, 55600 to 55603, 55700 to 55774, 55800 to 55854.
Where an item is within 3 hours of a charged item, then set the revised fee to zero.
If ultrasounds occurred at 9am, 11am and 1pm, then only the 11am fee would be set to zero.

 --->
<cfif ListFind(required_rules,'ULT') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ULT'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ULT">
                select  SB_HOURS_BETWEEN
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ULT.recordcount eq 0>
                The coning run requires the ULT (ultrasound multiple Service rule) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ULTITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ULTITEM.recordcount eq 0>
                The coning run requires the ULT (ultrasound multiple Service rule) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_ULTRASOUND">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER,
                    SB_CONING_ERROR,
                    SB_CONING_NOT_DUP_SERVICE
                FROM CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                <cfoutput query="ULTITEM">
                    <cfif ULTITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ULTITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ULTITEM.SB_MBS_ITEM_NUMBER#' and '#ULTITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                ORDER BY
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER
            </cfquery>

            <!--- If there is more than one ultrasound service, continue.. --->
            <cfif MULTIPLE_SERVICES_ULTRASOUND.RECORDCOUNT GT 1>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">
                <cfset MINIMUM_MINUTES = 60 * ult.SB_HOURS_BETWEEN>
                <!--- Loop through each record in MUTLIPLE_SERVICES_ULTRASOUND --->
                <cfloop query="MULTIPLE_SERVICES_ULTRASOUND">

                    <!---  For the same provider on the same day --->
                    <cfif (VARIABLES.SERVICE_DATE EQ "" AND VARIABLES.PROVIDER EQ "") OR
                            (APPLICATION.dateFunctions.parseDateTimeWithNULL(DateFormat(VARIABLES.SERVICE_DATE,'YYYY-MM-DD')) EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(DateFormat(MULTIPLE_SERVICES_ULTRASOUND.SB_SERVICE_DATE,'YYYY-MM-DD')) AND
                             VARIABLES.PROVIDER EQ MULTIPLE_SERVICES_ULTRASOUND.SB_CONING_PROVIDER)>

                             <cfif MULTIPLE_SERVICES_ULTRASOUND.CurrentRow eq 1>
                                <!--- This var is the date and time at which the first service has occured --->
                                <cfset VARIABLES.charged_item_time = MULTIPLE_SERVICES_ULTRASOUND.SB_SERVICE_DATE>
                             </cfif>

                             <!--- If a subsequent ultrasound occurs less than 3 hours after the charged item, it costs 0 --->
                             <!--- PAU-442 ULT Coning rule should not produce the error "item can only be claimed once every 3 hrs" for multiple service ultrasound if not dup service set to 'Y'.--->
                             <cfif DATEDIFF("N", VARIABLES.charged_item_time, MULTIPLE_SERVICES_ULTRASOUND.SB_SERVICE_DATE) LT MINIMUM_MINUTES and
                                    MULTIPLE_SERVICES_ULTRASOUND.CurrentRow neq 1
                                    AND MULTIPLE_SERVICES_ULTRASOUND.SB_CONING_NOT_DUP_SERVICE NEQ 'Y'>
                                    <cfset VARIABLES.ERROR_TEXT = #MULTIPLE_SERVICES_ULTRASOUND.SB_CONING_ERROR# & " Item can only be claimed once every #ult.SB_HOURS_BETWEEN# hours">
                                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
                                    <!--- Set the error message every record that is not the first in the series for a
                                        item and date --->
                                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_ULTRASOUND_error_text">
                                        UPDATE SB_CONING_RUN
                                            SET SB_ACTUAL_FEE = 0,
                                                SB_CONING_STATUS_CODE = 'ER',
                                                SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
                                        WHERE
                                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MULTIPLE_SERVICES_ULTRASOUND.SB_CONING_ID#">
                                    </cfquery>
                             <cfelse>
                                <!--- Update this variable to the date and time at which the last item was charged at` --->
                                 <cfset VARIABLES.charged_item_time = MULTIPLE_SERVICES_ULTRASOUND.SB_SERVICE_DATE>
                             </cfif>
                    </cfif>

                    <cfset VARIABLES.SERVICE_DATE = MULTIPLE_SERVICES_ULTRASOUND.SB_SERVICE_DATE>
                    <cfset VARIABLES.PROVIDER = MULTIPLE_SERVICES_ULTRASOUND.SB_CONING_PROVIDER>

                </cfloop>

            </cfif>

        </cfif>
    </cfloop>
</cfif>
  <!---  End Of Mutliple Services - Ultrasound rule --->

 <!--- Start of  Multiple Services - Vascular Ultrasound

Where more than one vascular ultrasound service (55238 to 55296) is provided to the same patient by the same practitioner on
the same date of service, the following formula applies to the Schedule fee for each service:
- 100% for the item with the greatest Schedule fee
- plus 60% for the item with the next greatest Schedule fee
- plus 50% for each other item

When the Schedule fee for some of the items are the same, the reduction is calculated in the following order:
- 100% for the item with the greatest Schedule fee and the lowest item number
- plus 60% for the item with the greatest Schedule fee and the second lowest item number
- plus 50% for each other item

  --->
<cfif ListFind(required_rules,'VULT') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'VULT'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="VULT">
                select  SB_RULE_PERCENT1,
                        SB_RULE_PERCENT2,
                        SB_RULE_PERCENT3,
                        SB_CONING_RULE_ID
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif VULT.recordcount eq 0>
                The coning run requires the VULT (Vascular ultrasound multiple Service rule) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="VULTITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif VULTITEM.recordcount eq 0>
                The coning run requires the VULT (Vascular ultrasound multiple Service rule) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_VASCULAR_ULTRASOUND">
                set dateformat dmy
                SELECT
                    SB_CONING_ID,
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER,
                    SB_ACTUAL_FEE,
                    SB_SCHEDULE_FEE,
                    SB_ITEM_NUMBER,
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103))
                FROM    SB_CONING_RUN
                WHERE   SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                AND CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)) = '#this_service_day#'
                AND (1 = 2
                <cfoutput query="VULTITEM">
                    <cfif VULTITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#VULTITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#VULTITEM.SB_MBS_ITEM_NUMBER#' and '#VULTITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                )
                ORDER BY
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)),
                    SB_CONING_PROVIDER,
                    SB_SCHEDULE_FEE DESC,
                    SB_ITEM_NUMBER,
                    SB_ACTUAL_FEE DESC
            </cfquery>

            <cfif MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.RECORDCOUNT GT 1>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">
                <cfset VARIABLES.item_count = 0>

                <cfloop query="MULTIPLE_SERVICES_VASCULAR_ULTRASOUND">

                    <cfif VARIABLES.SERVICE_DATE eq "">
                        <cfset parsed_date = "">
                    <cfelse>
                        <cfset parsed_date = APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE)>
                    </cfif>

                    <!--- For the first record, the SERVICE_DATE and  PROVIDER VARIABLES will be blank
                        The second and following records may be on the same date with same provider
                    --->
                    <cfset SERVICE_DAY = DateFormat(MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.SB_SERVICE_DATE,"dd-mmm-yyyy")>
                    <cfif parsed_date EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(SERVICE_DAY)
                        AND VARIABLES.PROVIDER EQ MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.SB_CONING_PROVIDER>

                        <!--- A second or subsequent record has been processed for the same day and provider --->
                        <cfset VARIABLES.item_count = VARIABLES.item_count + 1>

                        <cfif VARIABLES.item_count eq 1>
                            <cfset VARIABLES.reduced_rate = VULT.SB_RULE_PERCENT1 / 100>
                        <cfelseif VARIABLES.item_count eq 2>
                            <cfset VARIABLES.reduced_rate = VULT.SB_RULE_PERCENT2 / 100>
                        <cfelse>
                            <cfset VARIABLES.reduced_rate = VULT.SB_RULE_PERCENT3 / 100>
                        </cfif>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                            UPDATE SB_CONING_RUN
                                SET SB_ACTUAL_FEE = CEILING((ISNULL(SB_ACTUAL_FEE, 0) * #VARIABLES.reduced_rate#) / 0.05) * 0.05,
                                    CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'VULT') <= 100
                                                            THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'VULT' ELSE 'VULT' END)
                                                            ELSE CONING_RULES_APPLIED END
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.SB_CONING_ID#">
                        </cfquery>
                    <cfelse>
                        <!---  A record with a different date and provider has been processed  --->
                        <cfset VARIABLES.item_count = 1>
                        <!--- Update the service date and provider VARIABLES--->
                        <cfset VARIABLES.SB_CONING_ID = MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.SB_CONING_ID>
                        <cfset VARIABLES.SERVICE_DATE = SERVICE_DAY>
                        <cfset VARIABLES.PROVIDER = MULTIPLE_SERVICES_VASCULAR_ULTRASOUND.SB_CONING_PROVIDER>
                    </cfif>
                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>
 <!--- End of Multiple Services - Vascular Ultrasound --->

 <!--- Start of  Multiple Services - Musculo Skeletal

Where more than one MRI Musculo Skeletal service (59700 to 60078) is provided to the same patient by the same practitioner on
the same date of service, the following formula applies to the Schedule fee for each service:
- 100% for the item with the greatest Schedule fee
- plus 50% for each other item

  --->
<cfif ListFind(required_rules,'MMUS') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'MMUS'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MMUS">
                select  SB_RULE_PERCENT1,
                        SB_RULE_PERCENT2,
                        SB_RULE_PERCENT3,
                        SB_CONING_RULE_ID
                from    SB_CONING_RULE with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif MMUS.recordcount eq 0>
                The coning run requires the MMUS (Musulo Skeletal multiple Service rule) record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MMUSITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM with (nolock)
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif MMUSITEM.recordcount eq 0>
                The coning run requires the MMUS (Musulo Skeletal multiple Service rule) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTIPLE_SERVICES_MRI_MS">
                set dateformat dmy
                SELECT
                    SB_CONING_ID,
                    SB_SERVICE_DATE,
                    SB_CONING_PROVIDER,
                    SB_ACTUAL_FEE,
                    SB_SCHEDULE_FEE,
                    SB_ITEM_NUMBER,
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103))
                FROM    SB_CONING_RUN    with (nolock)
                WHERE   SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                AND CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)) = '#this_service_day#'
                AND (1 = 2
                <cfoutput query="MMUSITEM">
                    <cfif MMUSITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#MMUSITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#MMUSITEM.SB_MBS_ITEM_NUMBER#' and '#MMUSITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>
                )
                ORDER BY
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)),
                    SB_CONING_PROVIDER,
                    SB_SCHEDULE_FEE DESC,
                    SB_ITEM_NUMBER,
                    SB_ACTUAL_FEE DESC
            </cfquery>

            <cfif MULTIPLE_SERVICES_MRI_MS.RECORDCOUNT GT 1>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.PROVIDER = "">
                <cfset VARIABLES.item_count = 0>

                <cfloop query="MULTIPLE_SERVICES_MRI_MS">


                    <!--- For the first record, the SERVICE_DATE and  PROVIDER VARIABLES will be blank
                        The second and following records may be on the same date with same provider
                    --->
                    <cfset SERVICE_DAY = DateFormat(MULTIPLE_SERVICES_MRI_MS.SB_SERVICE_DATE,"dd-mmm-yyyy")>
                    <cfif VARIABLES.SERVICE_DATE EQ SERVICE_DAY
                        AND VARIABLES.PROVIDER EQ MULTIPLE_SERVICES_MRI_MS.SB_CONING_PROVIDER>

                        <!--- A second or subsequent record has been processed for the same day and provider --->
                        <cfset VARIABLES.item_count = VARIABLES.item_count + 1>

                        <cfif VARIABLES.item_count eq 1>
                            <cfset VARIABLES.reduced_rate = mmus.SB_RULE_PERCENT1 / 100>
                        <cfelseif VARIABLES.item_count eq 2>
                            <cfset VARIABLES.reduced_rate = mmus.SB_RULE_PERCENT2 / 100>
                        <cfelse>
                            <cfset VARIABLES.reduced_rate = mmus.SB_RULE_PERCENT3 / 100>
                        </cfif>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
                            UPDATE SB_CONING_RUN
                                SET SB_ACTUAL_FEE = CEILING((ISNULL(SB_ACTUAL_FEE, 0) * #VARIABLES.reduced_rate#) / 0.05) * 0.05,
                                    CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'MMUS') <= 100
                                                        THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'MMUS' ELSE 'MMUS' END)
                                                        ELSE CONING_RULES_APPLIED END
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MULTIPLE_SERVICES_MRI_MS.SB_CONING_ID#">
                        </cfquery>
                    <cfelse>
                        <!---  A record with a different date and provider has been processed  --->
                        <cfset VARIABLES.item_count = 1>
                        <!--- Update the service date and provider VARIABLES--->
                        <cfset VARIABLES.SB_CONING_ID = MULTIPLE_SERVICES_MRI_MS.SB_CONING_ID>
                        <cfset VARIABLES.SERVICE_DATE = SERVICE_DAY>
                        <cfset VARIABLES.PROVIDER = MULTIPLE_SERVICES_MRI_MS.SB_CONING_PROVIDER>
                    </cfif>
                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>
 <!--- End of Multiple Services - MRI Musculoskeletal --->


 <!--- Start of Musculoskeletal Ultrasound

Single rebate per day
Items 55800 to 55854 apply once a day for each patient regardless of the number of regions scanned.
Sort by dr  by item number. For each subsequent scan on the same day,
 set the error status.
 --->
<cfif ListFind(required_rules,'MULT') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'MULT'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MULTITEM">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif MULTITEM.recordcount eq 0>
                The coning run requires the MULT (Musculoskeletal Ultrasound) item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MUSCULOSKELETAL_ULTRASOUND">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SERVICE_DAY,
                    SB_ITEM_NUMBER,
                    SB_CONING_ERROR
                FROM CONING_RECORDS
                WHERE service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                (1 = 2
                <cfoutput query="MULTITEM">
                    <cfif MULTITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#MULTITEM.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#MULTITEM.SB_MBS_ITEM_NUMBER#' and '#MULTITEM.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                ORDER BY
                    SERVICE_DAY,
                    SB_ITEM_NUMBER
            </cfquery>

            <cfif MUSCULOSKELETAL_ULTRASOUND.RECORDCOUNT GT 1>

                <cfset VARIABLES.SERVICE_DATE = "">
                <cfset VARIABLES.ERROR_TEXT = "">
                <cfset VARIABLES.SB_ITEM_NUMBER = "">

                <cfloop query="MUSCULOSKELETAL_ULTRASOUND">

                    <cfif VARIABLES.SERVICE_DATE eq "">
                        <cfset parsed_date = "">
                    <cfelse>
                        <cfset parsed_date = APPLICATION.dateFunctions.parseDateTimeWithNULL(VARIABLES.SERVICE_DATE)>
                    </cfif>

                    <cfif parsed_date EQ APPLICATION.dateFunctions.parseDateTimeWithNULL(MUSCULOSKELETAL_ULTRASOUND.SERVICE_DAY)
                        and VARIABLES.SB_ITEM_NUMBER EQ MUSCULOSKELETAL_ULTRASOUND.SB_ITEM_NUMBER>

                        <cfset VARIABLES.ERROR_TEXT = #MUSCULOSKELETAL_ULTRASOUND.SB_CONING_ERROR# & " Item can only be claimed once per day.">
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
                        <!--- Set the error message every record that is not the first in the series for a
                        item and date --->
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MUSCULOSKELETAL_ULTRASOUND_error_text">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_STATUS_CODE = 'ER',
                                    SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MUSCULOSKELETAL_ULTRASOUND.SB_CONING_ID#">
                        </cfquery>

                    </cfif>
                    <cfset VARIABLES.SERVICE_DATE = MUSCULOSKELETAL_ULTRASOUND.SERVICE_DAY>
                    <cfset VARIABLES.SB_ITEM_NUMBER = MUSCULOSKELETAL_ULTRASOUND.SB_ITEM_NUMBER>

                </cfloop>

            </cfif>

        </cfif>
    </cfloop>
</cfif>
  <!--- End of Multiple Services - Musculoskeletal Ultrasound --->

  <!--- Start of CT Spine

If item 56233 exists, then two of 56220, 56221 and 56223 must exist for the same dr same day.
The fee for these two items will be set to zero. If two of these items do not exist, the update the
56233 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " Item requires
two of 56220, 56221 and 56223", and set sb_item_status_code to 'ER'.

If item 56234 exists, then two of 56224, 56225 and 56226 must exist for the same dr same day.
The fee for these two items will be set to zero. If two of these items do not exist, the update the
56234 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " Item requires
two of 56224, 56225 and 56226", and set sb_item_status_code to 'ER'.

If item 56235 exists, then two of 56227, 56228 and 56229 must exist for the same dr same day.
The fee for these two items will be set to zero. If two of these items do not exist, the update the
56235 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " Item requires
two of 56227, 56228 and 56229", and set sb_item_status_code to 'ER'.

If item 56236 exists, then two of 56230, 56231 and 56232 must exist for the same dr same day.
The fee for these two items will be set to zero. If two of these items do not exist, the update the
56236 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " Item requires
two of 56230, 56231 and 56232", and set sb_item_status_code to 'ER'.

=========================================================

Also does Radiographic Examination of the Spine (RSA and RSB)

If item 58112 exists, then two of 58100, 58103, 58106, 58109 must exist for the same dr same day.
The fee for these two items will be set to zero. If two of these items do not exist, then update the
58112 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & "
Item requires two of 58100, 58103, 58106, 58109", and set sb_item_status_code to 'ER'.
Where an item has the required dependant items, then the dependant item numbers are entered into
the message to HIC, as 'Items x, y performed'.

If item 58115 exists, then three of 58100, 58103, 58106, 58109 must exist for the same dr same day.
The fee for these three items will be set to zero. If three of these items do not exist, then update
the 58115 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & "
Item requires three of 58100, 58103, 58106, 58109 ", and set sb_item_status_code to 'ER'.
Where an item has the required dependant items, then the dependant item numbers are entered into
the message to HIC, as 'Items x, y, z performed'.
  --->

<cfloop index="CTItem" list="CTSPA,CTSPB,CTSPC,CTSPD,RSA,RSB,C112A,C115A,C108A">
    <cfif ListFind(required_rules,CTItem) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq CTItem>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>


                <!--- If item 56233 exists, then two of 56220, 56221 and 56223 must exist for the same dr same day.
            The fee for these two items will be set to zero. If two of these items do not exist, the update the
            56233 record so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " Item requires
            two of 56220, 56221 and 56223", and set sb_item_status_code to 'ER'. --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CTSP">
                    select  SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ID,
                            SB_ITEM_COUNT
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                    and     '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                </cfquery>
                <cfif CTSP.recordcount gt 0>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CTSPITEM">
                        select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                                SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                        from    SB_CONING_RULE_ITEM
                        where   SB_CONING_RULE_ID = #this_rule_id#
                    </cfquery>
                    <cfif CTSPITEM.recordcount eq 0>
                        The coning run requires the <cfoutput>#CTItem#</cfoutput> (CT Spine Rule A,B,C,D) item records to be defined.
                        <cfabort>
                    </cfif>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CT_SPINE_56233">
                        SET DATEFORMAT DMY;
                        WITH CONING_RECORDS
                        AS (
                            #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                        )
                        SELECT
                            SB_CONING_ID,
                            SERVICE_DAY,
                            SB_CONING_PROVIDER,
                            SB_CONING_ERROR,
                            SB_CONING_INVOICE_ID
                        FROM CONING_RECORDS
                        WHERE
                            service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                            SB_ITEM_NUMBER = '#CTSP.SB_MBS_ITEM_NUMBER#'
                        ORDER BY
                            SERVICE_DAY,
                            SB_CONING_PROVIDER
                    </cfquery>

                    <!--- If records exists continue processing CT Spine --->
                    <cfif CT_SPINE_56233.RECORDCOUNT GT 0 >

                        <cfloop query="CT_SPINE_56233">
                            <!---Modify query to check that the two combining item are in the sb_invoice_item_deleted table --->
                            <!--- Two of 56220, 56221 and 56223 must exists for the same doctor on same day --->
                            <cfquery name="CT_SPINE_56233_CHECK" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                                SET DATEFORMAT dmy
                                SELECT
                                    SB_MBS_ITEM_NUMBER
                                FROM
                                    SB_INVOICE_ITEM_DELETED
                                WHERE
                                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)) = CONVERT(DATETIME, '#DateFormat(CT_SPINE_56233.SERVICE_DAY, 'dd/MMM/yyyy')#') AND
                                    SB_INVOICE_ID = #CT_SPINE_56233.sb_coning_invoice_id# AND
                                    (1 = 2
                            <cfoutput query="CTSPITEM">
                                <cfif CTSPITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or SB_MBS_ITEM_NUMBER = '#CTSPITEM.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or SB_MBS_ITEM_NUMBER BETWEEN '#CTSPITEM.SB_MBS_ITEM_NUMBER#' and '#CTSPITEM.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                                    )
                            </cfquery>

                            <cfif CT_SPINE_56233_CHECK.RECORDCOUNT NEQ ctsp.SB_ITEM_COUNT>
                                <!--- Increment the Error Count --->
                                <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                                <!--- Update with Error Message --->
                                <cfset items_reqd = ''>
                                <cfoutput query="CTSPITEM">
                                    <cfset items_reqd = Trim(items_reqd & " " & CTSPITEM.SB_MBS_ITEM_NUMBER)>
                                </cfoutput>
                                <cfset VARIABLES.ERROR_TEXT = CT_SPINE_56233.SB_CONING_ERROR & " Item requires #ctsp.SB_ITEM_COUNT# of #items_reqd# Rule #CTItem#">

                                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                                    UPDATE SB_CONING_RUN
                                        SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                        SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#CT_SPINE_56233.SB_CONING_ID#">
                                </cfquery>
                            <cfelse>
                                <cfset VARIABLES.ITEM_LIST = "">
                                <cfset item_number_count = '0'>
                                <!--- Set Price to zero --->
                                <cfloop query="CT_SPINE_56233_CHECK">
                                    <cfif  CT_SPINE_56233_CHECK.RECORDCOUNT neq item_number_count>
                                        <cfset item_number_count = item_number_count + 1>
                                        <cfset VARIABLES.ITEM_LIST = VARIABLES.ITEM_LIST & CT_SPINE_56233_CHECK.SB_MBS_ITEM_NUMBER & ", ">
                                    <cfelse>
                                        <cfset VARIABLES.ITEM_LIST = VARIABLES.ITEM_LIST & CT_SPINE_56233_CHECK.SB_MBS_ITEM_NUMBER>
                                    </cfif>

                                </cfloop>

                                <!--- Update message to HIC for the Item --->
                                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                                    UPDATE SB_CONING_RUN
                                        SET SB_CONING_MSG_TO_HIC = 'Items ' + '#VARIABLES.ITEM_LIST#' + ' performed'
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#CT_SPINE_56233.SB_CONING_ID#">
                                </cfquery>
                            </cfif>
                        </cfloop>
                    </cfif>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

<!--- End of CT Spine / Radiographic Examination of the Spine Rules --->

<!--- Start of Myocardial Perfusion Studies

If items 61302 and 61303 exist for the same day, then items 61306 or 61307 should not
also exist for the same day. If 61306 or 61307 also exist, then update the 61302 record
so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & " For single myocardial
perfusion studies, items 61302 and 61303 cannot coexist with 6130 or 61307", and set sb_item_status_code
to 'ER'.
 Item 42731 not payable in association with items 42551 to 42566, 42569, 42698 to 42707, 42716, 42734, 42743 to 42746,
42761 to 42767, 42815, 42857 for same dr same day.
Flag as an error, status = 'ER', message is 'Item 42731 cannot be claimed with items 42551 to 42566, 42569, 42698 to 42707, 42716,
42734, 42743 to 42746, 42761 to 42767, 42815, 42857'.
 --->

<cfloop index="MPSItem" list="MPS1,MPS2,MEX2,MEX3">
    <cfif ListFind(required_rules,MPSItem) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq MPSItem>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MPS">
                    select  SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ID,
                            SB_ITEM_COUNT
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif MPS.recordcount eq 0>
                    The coning run requires the <cfoutput>#MPSItem#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MPSExclude">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif MPSExclude.recordcount eq 0>
                    The coning run requires the <cfoutput>#MPSItem#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MPS_ITEMS">
                    SET DATEFORMAT DMY;
                    WITH CONING_RECORDS
                    AS (
                        #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                    )
                    SELECT
                        SB_CONING_ID,
                        SERVICE_DAY,
                        SB_CONING_PROVIDER,
                        SB_CONING_ERROR
                    FROM CONING_RECORDS
                    WHERE
                        service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (1 = 2
                        <cfoutput query="MPSExclude">
                            <cfif MPSExclude.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#MPSExclude.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#MPSExclude.SB_MBS_ITEM_NUMBER#' and '#MPSExclude.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>)
                    ORDER BY
                        SERVICE_DAY,
                        SB_CONING_PROVIDER
                </cfquery>

                <!--- If records exists continue processing CT Spine --->
                <cfif MPS_ITEMS.RECORDCOUNT GT 0 >

                    <cfloop query="MPS_ITEMS">
                        <!--- Two of 56220, 56221 and 56223 must exists for the same doctor on same day --->
                        <cfquery name="MPS_ITEMS_CHECK" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                            SET DATEFORMAT dmy
                            SELECT
                                SB_CONING_ID,
                                SB_ITEM_NUMBER
                            FROM
                                SB_CONING_RUN
                            WHERE
                                CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE, 103)) = CONVERT(DATETIME, '#DateFormat(MPS_ITEMS.SERVICE_DAY, 'dd/MMM/yyyy')#') AND
                                SB_CONING_PROVIDER ='#MPS_ITEMS.SB_CONING_PROVIDER#' AND
                                SB_ITEM_NUMBER = '#MPS.SB_MBS_ITEM_NUMBER#' AND
                                SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        </cfquery>

                        <cfif MPS_ITEMS_CHECK.RECORDCOUNT NEQ 0>
                            <!--- Increment the Error Count --->
                            <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                            <!--- Update with Error Message --->
                            <cfset items_excl = ''>
                            <cfoutput query="MPSExclude">
                                <cfif MPSExclude.SB_MBS_ITEM_NUMBER_TO eq "">
                                    <cfset items_excl = trim(items_excl & " " & MPSExclude.SB_MBS_ITEM_NUMBER)>
                                <cfelse>
                                    <cfset items_excl = trim(items_excl & " " & MPSExclude.SB_MBS_ITEM_NUMBER & " - " & MPSExclude.SB_MBS_ITEM_NUMBER_TO)>
                                </cfif>
                            </cfoutput>
                            <cfset VARIABLES.ERROR_TEXT = MPS_ITEMS.SB_CONING_ERROR & " Item #MPS.SB_MBS_ITEM_NUMBER# cannot co-exist with #items_excl#">

                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                                UPDATE SB_CONING_RUN
                                    SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                    SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                                WHERE
                                    SB_CONING_ID = #MPS_ITEMS.SB_CONING_ID#
                            </cfquery>
                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                                UPDATE SB_CONING_RUN
                                    SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                    SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                                WHERE
                                    SB_CONING_ID = #MPS_ITEMS_CHECK.SB_CONING_ID#
                            </cfquery>
                        </cfif>
                    </cfloop>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

<!---   End of Myocardial Perfusion Studies --->

<!--- Start of Magnetic Resonance Imaging

Only one benefit can be claimed in a 12 month period for the following items:
63000 to 63162, 63300 to 63574, 63600 to 63721, 63750 to 63756, 63870, 63900 to 63930
It does not matter which performed the service. This rule applies to each item no separately,
not as a group. E.g. It is OK for a patient to have a 63000 and 63001 in the same year.
Where a subsequent item occurs within the 12 month period, the fee for the subsequent item will be set
to zero. When doing the comparison, ignore any previous items that have zero sb_invoice_cost..

Only two benefits can be claimed in a 12 month period for the following items:
63200 to 63256, 63745, 63800 to 63868.
It does not matter which performed the service. This rule applies to each item no separately,
not as a group. E.g. It is OK for a patient to have two 63200 and two 63201 in the same year.
Where a second subsequent item occurs within the 12 month period, the fee for the second subsequent
item will be set to zero. When doing the comparison, ignore any previous items that have
zero sb_invoice_cost.

 --->
<!--- Only one benefit can be claimed in a 24 month period for the following items: 12306, 12309, 12315 and 12318. It does not matter
which Dr performed the service. This rule applies to each item no separately, not as a group.
 E.g. It is OK for a patient to have
 a 12306 and 12309 in the same 2 year period.

 Where a subsequent item occurs within the 24 month period, flag it as an error,
 status = 'ER', message is 'Item can only be claimed once per 24 months. Item was previously claimed on dd-mmm-yyyy' --->
<!--- Only one benefit can be claimed in a 12 month period for the following items: 12312 and 12321. It does not matter
 which Dr performed the service. This rule applies to each item no separately, not as a group. E.g. It is OK for a patient to have
 a 12312 and 12321in the same 12 month period. Where a subsequent item occurs within the 12 month period, flag it as an error,
 status = 'ER', message is 'Item can only be claimed once per 12 months. Item was previously claimed on dd-mmm-yyyy' --->

<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="PRDRules" returnvariable="PRDRules">
<cfset derived_list = "MRI1,MRI2,MRI3,PER24,PER12,PER4,PR242,PR244">
<cfoutput query="PRDRules">
    <cfif !listfindnocase(derived_list, #PRDRules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#PRDRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="MRIRule" list="#derived_list#">
    <cfif ListFind(required_rules,MRIRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq MRIRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QMRI">
                    select  SB_MAX_ITEMS_PER_PERIOD,
                            SB_DAYS_IN_PERIOD
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QMRI.recordcount eq 0>
                    The coning run requires the <cfoutput>#MRIRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QMRIItem">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QMRIItem.recordcount eq 0>
                    The coning run requires the <cfoutput>#MRIRule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI">
                    SELECT
                        RUN.SB_CONING_ITEM_ID,
                        RUN.SB_ITEM_NUMBER
                    FROM
                        SB_CONING_RUN RUN INNER JOIN
                        SB_INVOICE_ITEM ITEM ON
                            RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                        SB_INVOICE INVOICE ON
                            ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                        SB_INVOICE INVOICE2 ON
                            INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                            INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE AND
                            INVOICE2.SB_BILL_MECH_CODE NOT IN ('c','co','h') INNER JOIN
                        SB_INVOICE_ITEM ITEM2 ON
                            INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                            RUN.SB_ITEM_NUMBER = ITEM2.SB_MBS_ITEM_NUMBER AND
                            -- DO NOT COMPARE THE RECORD TO ITSELF
                            RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                            -- INCLUDE ONLY CLAIMED ITEMS
                            (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                            -- INCLUDE ONLY THOSE WHERE THE DIFFERENCE IN YEARS IS LESS THAN 1
                            AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                            AND ABS(DATEDIFF(DAY,  CONVERT(DATETIME, CONVERT(VARCHAR, ITEM2.SB_SERVICE_DATE,103)),  CONVERT(DATETIME, CONVERT(VARCHAR, RUN.SB_SERVICE_DATE,103)))) < #QMRI.SB_DAYS_IN_PERIOD#
                    WHERE
                            CONVERT(DATETIME, CONVERT(VARCHAR,run.SB_SERVICE_DATE,103)) = '#this_service_day#'
                            and     (1 = 2
                            <cfoutput query="QMRIItem">
                                <cfif QMRIItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or RUN.SB_ITEM_NUMBER = '#QMRIItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or RUN.SB_ITEM_NUMBER BETWEEN '#QMRIItem.SB_MBS_ITEM_NUMBER#' and '#QMRIItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                                    ) and
                            SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                    GROUP BY
                        RUN.SB_CONING_ITEM_ID,
                        RUN.SB_ITEM_NUMBER
                    HAVING COUNT(ITEM2.SB_INVOICE_ITEM_ID) >= #QMRI.SB_MAX_ITEMS_PER_PERIOD#
                </cfquery>



                <cfif MRI.RECORDCOUNT NEQ 0>
                    <cfoutput query="MRI">

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI_CHECK">
                            SELECT
                                SB_CONING_ID,
                                SB_CONING_ERROR
                            FROM
                                SB_CONING_RUN
                            WHERE
                                SB_CONING_ITEM_ID = #MRI.SB_CONING_ITEM_ID# and
                                SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                        </cfquery>

                        <cfset VARIABLES.ERROR_TEXT = MRI_CHECK.SB_CONING_ERROR & " Item can only be claimed #QMRI.SB_MAX_ITEMS_PER_PERIOD# times per #QMRI.SB_DAYS_IN_PERIOD# days.">
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI_error">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                SB_CONING_STATUS_CODE = 'ER'
                            WHERE
                                SB_CONING_ITEM_ID = #MRI.SB_CONING_ITEM_ID# and
                                SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                        </cfquery>
                    </cfoutput>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'MRI4') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'MRI4'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>
            <!--- If an item number in the range 63491 - 63497 is entered
                    an item in the range 63001 - 63473 must also be entered
         --->

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI4">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif MRI4.recordcount eq 0>
                The coning run requires the MRI4 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI5">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'MRI5'
            </cfquery>
            <cfif MRI5.recordcount eq 0>
                The coning run requires the MRI5 item records to be defined.
                <cfabort>
            </cfif>
            <!--- RANGE 20100 TO 21997 --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI4_BILLING_RANGE_1">
                set dateformat dmy

                SELECT
                    R1.SB_CONING_ID,
                    R1.SB_ITEM_NUMBER,
                    R1.SB_CONING_ERROR,
                    R2.SB_CONING_ID as required_item
                FROM
                    SB_CONING_RUN R1
                    LEFT OUTER JOIN SB_CONING_RUN R2
                    ON R1.SB_CONING_RUN_NO = R2.SB_CONING_RUN_NO
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103))
                        = CONVERT(DATETIME, CONVERT(VARCHAR, R2.SB_SERVICE_DATE,103))
                    and
                    (1 = 2
                <cfoutput query="MRI5">
                    <cfif MRI5.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R2.SB_ITEM_NUMBER = '#MRI5.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R2.SB_ITEM_NUMBER BETWEEN '#MRI5.SB_MBS_ITEM_NUMBER#' and '#MRI5.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                WHERE
                        R1.SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                    AND (1 = 2
                <cfoutput query="MRI4">
                    <cfif MRI4.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R1.SB_ITEM_NUMBER = '#MRI4.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R1.SB_ITEM_NUMBER BETWEEN '#MRI4.SB_MBS_ITEM_NUMBER#' and '#MRI4.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>


            <cfset VARIABLES.ERROR_TEXT = "">

            <!--- Record an error for range 1 --->
            <cfloop query="MRI4_BILLING_RANGE_1">

                <cfif MRI4_BILLING_RANGE_1.required_item eq "">
                    <cfset VARIABLES.ERROR_TEXT = #MRI4_BILLING_RANGE_1.SB_CONING_ERROR# & " MRI procedure requires an item from 63001 to 63473">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI4_BILLING_RANGE_1_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MRI4_BILLING_RANGE_1.SB_CONING_ID#">
                    </cfquery>
                </cfif>
            </cfloop>

            <cfset VARIABLES.ERROR_TEXT = "">

        </cfif>
    </cfloop>
</cfif>

<!--- Get list of user defined rules, of type LIG - Limit Services for group
Items are restricted as a group to a defined number within a given period.
Each item counts towards the total - they do not apply individually to each item. --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="LIGRules" returnvariable="LIGRules">
<cfset derived_list = "!">
<cfoutput query="LIGRules">
    <cfif !listfindnocase(derived_list, #LIGRules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#LIGRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="LIGRule" list="#derived_list#">
    <cfif ListFind(required_rules,LIGRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq LIGRule>
                <cfset VARIABLES.ERROR_TEXT = "">
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="LIG">
                    select  SB_MAX_ITEMS_PER_PERIOD,
                            SB_DAYS_IN_PERIOD
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif LIG.recordcount eq 0>
                    The coning run requires the <cfoutput>#LIGRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="LIGItem">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif LIGItem.recordcount eq 0>
                    The coning run requires the <cfoutput>#LIGRule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

<!--- Find all items that are relevant to the edit check --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="LIGCheck">
                    SET DATEFORMAT DMY
                    SELECT  ITEM.SB_SERVICE_DATE,
                            ITEM.sb_invoice_item_id,
                            invoice.sb_invoice_date
                    FROM
                        SB_INVOICE_ITEM ITEM
                            INNER JOIN
                        SB_INVOICE INVOICE ON
                            ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID
                    WHERE
                            ITEM.SB_ITEM_STATUS_CODE <> '98'
                        AND ITEM.SB_ITEM_STATUS_CODE <> '99'
                        AND (ITEM.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM.SB_FUND_AMOUNT_PAID,0) > 0)
                        AND INVOICE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
                        AND INVOICE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
                        AND INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
                        AND ABS(DATEDIFF(DAY,  CONVERT(DATETIME, CONVERT(VARCHAR, ITEM.SB_SERVICE_DATE,103)),  '#this_service_day#')) < #LIG.SB_DAYS_IN_PERIOD#
                        and     (1 = 2
                            <cfoutput query="LIGItem">
                                <cfif LIGItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or ITEM.SB_MBS_ITEM_NUMBER = '#LIGItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or ITEM.SB_MBS_ITEM_NUMBER BETWEEN '#LIGItem.SB_MBS_ITEM_NUMBER#' and '#LIGItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                                    )
                    ORDER BY item.SB_SERVICE_DATE
                </cfquery>
<!--- For each of these items, count the number of related items that proceed them in
the edit period concerned --->
                <cfloop query="LIGCheck">
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="LIGCount">
                        select count(*) as cnt
                        FROM
                            SB_INVOICE_ITEM ITEM
                                INNER JOIN
                            SB_INVOICE INVOICE ON
                                ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID
                        WHERE
                                ITEM.SB_ITEM_STATUS_CODE <> '98'
                            AND ITEM.SB_ITEM_STATUS_CODE <> '99'
                            AND (ITEM.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM.SB_FUND_AMOUNT_PAID,0) > 0)
                            AND INVOICE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
                            AND INVOICE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
                            AND INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
                            AND ITEM.SB_SERVICE_DATE >= '#DateFormat(Dateadd("d",-1 * LIG.SB_DAYS_IN_PERIOD,LIGCheck.SB_SERVICE_DATE),"dd-mmm-yyyy")#'
                            and ITEM.SB_SERVICE_DATE <= '#DateFormat(LIGCheck.SB_SERVICE_DATE,"dd-mmm-yyyy")# 23:59:59'
                            and     (1 = 2
                                <cfoutput query="LIGItem">
                                    <cfif LIGItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                        or ITEM.SB_MBS_ITEM_NUMBER = '#LIGItem.SB_MBS_ITEM_NUMBER#'
                                    <cfelse>
                                        or ITEM.SB_MBS_ITEM_NUMBER BETWEEN '#LIGItem.SB_MBS_ITEM_NUMBER#' and '#LIGItem.SB_MBS_ITEM_NUMBER_TO#'
                                    </cfif>
                                </cfoutput>
                                        )
                    </cfquery>
                    <cfif LIGCount.cnt gt lig.SB_MAX_ITEMS_PER_PERIOD>
                        <cfset VARIABLES.ERROR_TEXT = "Item is part of group that can only be claimed #LIG.SB_MAX_ITEMS_PER_PERIOD# times per #LIG.SB_DAYS_IN_PERIOD# days.">
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="LIG_error">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                SB_CONING_STATUS_CODE = 'ER'
                            WHERE
                                SB_CONING_RUN_NO = '#VARIABLES.unique_id#' AND
                                SB_CONING_STATUS_CODE <> 'ER'
                            AND (1 = 2
                                <cfoutput query="LIGItem">
                                    <cfif LIGItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                        or SB_ITEM_NUMBER = '#LIGItem.SB_MBS_ITEM_NUMBER#'
                                    <cfelse>
                                        or SB_ITEM_NUMBER BETWEEN '#LIGItem.SB_MBS_ITEM_NUMBER#' and '#LIGItem.SB_MBS_ITEM_NUMBER_TO#'
                                    </cfif>
                                </cfoutput>
                                )
                        </cfquery>

                        <cfbreak>
                    </cfif>
                </cfloop>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>
<!--- End of Magnetic Resonance Imaging --->

<!--- Start of  Anaesthetic Billing Rules

If at least 1 item in the range 20100 to 21997 is entered, then at least one item in the range 23010 to 24136 must also exist,
 and vice versa. If an item in one range exists without an item in the other range,  then update the item so that
 sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error & "Anaesthetic accounts require an item from 20100 to 21997,
 and from 23010 to 24136", and set sb_item_status_code to 'ER'.

If an item number in the range 18213 - 18370 is entered and an item between 20100 - 25205 has already been raised/entered for the
same servicing provider,  then update the item so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error &
"Associated item already raised'", and set sb_item_status_code to 'ER'.

Check that no more than one item exists in the range 25000 - 25020. If more than one exists, flag both as an error, status = 'ER',
message is 'Only one item in the range 25000 - 25020 may be entered'.

Check that no more than one item exists in the range 23010 - 24136. If more than one exists, flag both as an error, status = 'ER',
 message is 'Only one item in the range 23010 - 24136 may be entered'.
 --->
<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE1') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE1'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>
            <!--- If an item number in the range 18213 - 18370 is entered and an item between 20100 - 25205 has already been raised/entered for the
        same servicing provider,  then update the item so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error &
        "Associated item already raised'", and set sb_item_status_code to 'ER'. --->

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE1">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE1.recordcount eq 0>
                The coning run requires the ANAE1 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE2">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE2'
            </cfquery>
            <cfif ANAE2.recordcount eq 0>
                The coning run requires the ANAE2 item records to be defined.
                <cfabort>
            </cfif>
            <!--- RANGE 20100 TO 21997 --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_1">
                set dateformat dmy

                SELECT
                    R1.SB_CONING_ID,
                    R1.SB_ITEM_NUMBER,
                    R1.SB_CONING_ERROR,
                    R2.SB_CONING_ID as required_item
                FROM
                    SB_CONING_RUN R1
                    LEFT OUTER JOIN SB_CONING_RUN R2
                    ON R1.SB_CONING_RUN_NO = R2.SB_CONING_RUN_NO
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103))
                        = CONVERT(DATETIME, CONVERT(VARCHAR, R2.SB_SERVICE_DATE,103))
                    and
                    (1 = 2
                <cfoutput query="ANAE2">
                    <cfif ANAE2.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R2.SB_ITEM_NUMBER = '#ANAE2.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R2.SB_ITEM_NUMBER BETWEEN '#ANAE2.SB_MBS_ITEM_NUMBER#' and '#ANAE2.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                WHERE
                        R1.SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                    AND (1 = 2
                <cfoutput query="ANAE1">
                    <cfif ANAE1.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R1.SB_ITEM_NUMBER = '#ANAE1.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R1.SB_ITEM_NUMBER BETWEEN '#ANAE1.SB_MBS_ITEM_NUMBER#' and '#ANAE1.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>


            <cfset VARIABLES.ERROR_TEXT = "">

            <!--- Record an error for range 1 --->
            <cfloop query="ANAESTHETIC_BILLING_RANGE_1">

                <cfif ANAESTHETIC_BILLING_RANGE_1.required_item eq "">
                    <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_1.SB_CONING_ERROR# & " Anaesthetic accounts require an item from 20100 to 21997, and from 23010  to 24136" >
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_1_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_1.SB_CONING_ID#">
                    </cfquery>
                </cfif>
            </cfloop>

            <cfset VARIABLES.ERROR_TEXT = "">

        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE2') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE2'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE2">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE2.recordcount eq 0>
                The coning run requires the ANAE2 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE1">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE1'
            </cfquery>
            <cfif ANAE1.recordcount eq 0>
                The coning run requires the ANAE1 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_2">
                SELECT
                    R1.SB_CONING_ID,
                    R1.SB_ITEM_NUMBER,
                    R1.SB_CONING_ERROR,
                    R2.SB_CONING_ID as required_item
                FROM
                    SB_CONING_RUN R1
                    LEFT OUTER JOIN SB_CONING_RUN R2
                    ON R1.SB_CONING_RUN_NO = R2.SB_CONING_RUN_NO
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103))
                        = CONVERT(DATETIME, CONVERT(VARCHAR, R2.SB_SERVICE_DATE,103))
                    AND (1 = 2
                <cfoutput query="ANAE1">
                    <cfif ANAE1.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R2.SB_ITEM_NUMBER = '#ANAE1.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R2.SB_ITEM_NUMBER BETWEEN '#ANAE1.SB_MBS_ITEM_NUMBER#' and '#ANAE1.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                WHERE
                        R1.SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                    AND CONVERT(DATETIME, CONVERT(VARCHAR, R1.SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                    AND (1 = 2
                <cfoutput query="ANAE2">
                    <cfif ANAE2.SB_MBS_ITEM_NUMBER_TO eq "">
                        or R1.SB_ITEM_NUMBER = '#ANAE2.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or R1.SB_ITEM_NUMBER BETWEEN '#ANAE2.SB_MBS_ITEM_NUMBER#' and '#ANAE2.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <!--- Record an error for range 2 --->
            <cfloop query="ANAESTHETIC_BILLING_RANGE_2">

                <cfif ANAESTHETIC_BILLING_RANGE_2.required_item eq "">

                    <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_2.SB_CONING_ERROR# & " Anaesthetic accounts require an item from 20100 to 21997, and from 23010  to 24136" >
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_2_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_2.SB_CONING_ID#">
                    </cfquery>
                </cfif>
            </cfloop>
        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE3') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE3'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE3">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE3.recordcount eq 0>
                The coning run requires the ANAE3 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE4">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE4'
            </cfquery>
            <cfif ANAE4.recordcount eq 0>
                The coning run requires the ANAE4 item records to be defined.
                <cfabort>
            </cfif>


            <!--- If an item number in the range 18213 - 18370 is entered and an item between 20100 - 25205 has already been raised/entered for the
        same servicing provider,  then update the item so that sb_invoice_item.sb_outpat_error = sb_invoice_item.sb_outpat_error &
        "Associated item already raised'", and set sb_item_status_code to 'ER'. --->
            <!--- RANGE 18213 TO 18370 --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_3">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_CONING_ERROR,
                    SB_CONING_PROVIDER,
                    SERVICE_DAY
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                    and (1 = 2
                <cfoutput query="ANAE3">
                    <cfif ANAE3.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ANAE3.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ANAE3.SB_MBS_ITEM_NUMBER#' and '#ANAE3.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfset VARIABLES.ERROR_TEXT = "">

            <cfif   ANAESTHETIC_BILLING_RANGE_3.RECORDCOUNT GT 0>
                <cfloop query="ANAESTHETIC_BILLING_RANGE_3">
                    <!--- Check to see if there is an item in the range 20100 to 25205 --->
                    <cfquery name="ANAESTHETIC_BILLING_RANGE_3_CHECK"  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                        SELECT
                            COUNT(SB_CONING_ID) AS ALREADY_RAISED
                        FROM
                            SB_CONING_RUN
                        WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#DateFormat(ANAESTHETIC_BILLING_RANGE_3.SERVICE_DAY,"dd-mmm-yyyy")#'
                        and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                        AND (1 = 2
                        <cfoutput query="ANAE4">
                            <cfif ANAE4.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#ANAE4.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#ANAE4.SB_MBS_ITEM_NUMBER#' and '#ANAE4.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                        ) and
                            SB_CONING_PROVIDER = '#ANAESTHETIC_BILLING_RANGE_3.SB_CONING_PROVIDER#'
                    </cfquery>

                    <cfif ANAESTHETIC_BILLING_RANGE_3_CHECK.ALREADY_RAISED GT 0>

                        <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_3.SB_CONING_ERROR# & " Associated items already raised. ( 20100 - 25205 ) cannot be used with (18213 - 18370)." >
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_3_error">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_3.SB_CONING_ID#">
                        </cfquery>
                    </cfif>
                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE4') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE4'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE4">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE4.recordcount eq 0>
                The coning run requires the ANAE4 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE3">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE3'
            </cfquery>
            <cfif ANAE3.recordcount eq 0>
                The coning run requires the ANAE3 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_4">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_CONING_ERROR,
                    SB_CONING_PROVIDER,
                    SERVICE_DAY
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                    and (1 = 2
                <cfoutput query="ANAE4">
                    <cfif ANAE4.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ANAE4.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ANAE4.SB_MBS_ITEM_NUMBER#' and '#ANAE4.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfset VARIABLES.ERROR_TEXT = "">

            <cfif   ANAESTHETIC_BILLING_RANGE_4.RECORDCOUNT GT 0>
                <cfloop query="ANAESTHETIC_BILLING_RANGE_4">
                    <!--- Check to see if there is an item in the range 20100 to 25205 --->
                    <cfquery name="ANAESTHETIC_BILLING_RANGE_4_CHECK"  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                        SELECT
                            COUNT(SB_CONING_ID) AS ALREADY_RAISED
                        FROM
                            SB_CONING_RUN
                        WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#DateFormat(ANAESTHETIC_BILLING_RANGE_4.SERVICE_DAY,"dd-mmm-yyyy")#'
                        and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                        AND (1 = 2
                        <cfoutput query="ANAE3">
                            <cfif ANAE3.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#ANAE3.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#ANAE3.SB_MBS_ITEM_NUMBER#' and '#ANAE3.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                        ) and
                            SB_CONING_PROVIDER = '#ANAESTHETIC_BILLING_RANGE_4.SB_CONING_PROVIDER#'
                    </cfquery>

                    <cfif ANAESTHETIC_BILLING_RANGE_4_CHECK.ALREADY_RAISED GT 0>

                        <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_4.SB_CONING_ERROR# & " Associated item ( 20100 - 25205 ) already raised. " >
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_4_error">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_4.SB_CONING_ID#">
                        </cfquery>
                    </cfif>
                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE5') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE5'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE5">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE5.recordcount eq 0>
                The coning run requires the ANAE5 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE6">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE6'
            </cfquery>
            <cfif ANAE6.recordcount eq 0>
                The coning run requires the ANAE6 item records to be defined.
                <cfabort>
            </cfif>

        <!--- Check that no more than one item exists in the range 25000 - 25020. If more than one exists, flag both as an error, status = 'ER',
        message is 'Only one item in the range 25000 - 25020 may be entered'.
        srt 02-03-2006 added sb_coning_not_dup_service = 'n' for chad
        --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_5">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SERVICE_DAY
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (sb_coning_not_dup_service = 'n' or sb_coning_not_dup_service = 'N') and
                    (   1 = 2
                <cfoutput query="ANAE5">
                    <cfif ANAE5.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ANAE5.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ANAE5.SB_MBS_ITEM_NUMBER#' and '#ANAE5.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                GROUP BY SERVICE_DAY
                HAVING COUNT(*) > 1
            </cfquery>

            <!--- If more than one exists flag them as errors --->
            <cfif ANAESTHETIC_BILLING_RANGE_5.recordcount gt 0>

                <cfquery name="ANAESTHETIC_BILLING_RANGE_5A" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR
                        FROM
                            SB_CONING_RUN
                        WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#DateFormat(ANAESTHETIC_BILLING_RANGE_5.SERVICE_DAY,"dd-mmm-yyyy")#'
                        AND CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                        AND (       1 = 2
                    <cfoutput query="ANAE5">
                        <cfif ANAE5.SB_MBS_ITEM_NUMBER_TO eq "">
                            or SB_ITEM_NUMBER = '#ANAE5.SB_MBS_ITEM_NUMBER#'
                        <cfelse>
                            or SB_ITEM_NUMBER BETWEEN '#ANAE5.SB_MBS_ITEM_NUMBER#' and '#ANAE5.SB_MBS_ITEM_NUMBER_TO#'
                        </cfif>
                    </cfoutput>)
                </cfquery>

                <cfloop query="ANAESTHETIC_BILLING_RANGE_5A">

                    <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_5a.SB_CONING_ERROR# & "Only one item in the range 25000 to 25020 may be entered">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_5_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_5a.SB_CONING_ID#">
                    </cfquery>

                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'ANAE6') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ANAE6'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE6">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ANAE6.recordcount eq 0>
                The coning run requires the ANAE6 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE5">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'ANAE5'
            </cfquery>
            <cfif ANAE5.recordcount eq 0>
                The coning run requires the ANAE5 item records to be defined.
                <cfabort>
            </cfif>

            <cfset VARIABLES.ERROR_TEXT = "">

        <!--- Check that no more than one item exists in the range 25000 - 25020. If more than one exists, flag both as an error, status = 'ER',
        message is 'Only one item in the range 25000 - 25020 may be entered'. --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_6">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SERVICE_DAY
                FROM
                    CONING_RECORDS
                WHERE
                    service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                    (SB_CONING_NOT_DUP_SERVICE = 'n' or SB_CONING_NOT_DUP_SERVICE = 'N' ) and
                    (   1 = 2
                <cfoutput query="ANAE6">
                    <cfif ANAE6.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#ANAE6.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#ANAE6.SB_MBS_ITEM_NUMBER#' and '#ANAE6.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
                GROUP BY SERVICE_DAY
                HAVING COUNT(*) > 1
            </cfquery>

            <!--- If more than one exists flag them as errors --->
            <cfif ANAESTHETIC_BILLING_RANGE_6.recordcount gt 0>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_6A">
                    SET DATEFORMAT DMY
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR
                    FROM
                        SB_CONING_RUN
                    WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                    and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#DateFormat(ANAESTHETIC_BILLING_RANGE_6.SERVICE_DAY,"dd-mmm-yyyy")#'
                    and   CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day_mmm#'
                    AND (       1 = 2
                    <cfoutput query="ANAE6">
                        <cfif ANAE6.SB_MBS_ITEM_NUMBER_TO eq "">
                            or SB_ITEM_NUMBER = '#ANAE6.SB_MBS_ITEM_NUMBER#'
                        <cfelse>
                            or SB_ITEM_NUMBER BETWEEN '#ANAE6.SB_MBS_ITEM_NUMBER#' and '#ANAE6.SB_MBS_ITEM_NUMBER_TO#'
                        </cfif>
                    </cfoutput>)
                </cfquery>


                <cfloop query="ANAESTHETIC_BILLING_RANGE_6A">

                    <cfset VARIABLES.ERROR_TEXT = #ANAESTHETIC_BILLING_RANGE_6a.SB_CONING_ERROR# & "Only one item in the range 23010 to 24136 may be entered">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAESTHETIC_BILLING_RANGE_6_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAESTHETIC_BILLING_RANGE_6a.SB_CONING_ID#">
                    </cfquery>

                </cfloop>

            </cfif>
        </cfif>
    </cfloop>
</cfif>


<cfset VARIABLES.ERROR_TEXT = "">

<cfif ListFind(required_rules,'PER99') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'PER99'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="PER99">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif PER99.recordcount eq 0>
                The coning run requires the PER99 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="per99_services">
                SELECT
                    RUN.SB_CONING_ID,
                    RUN.SB_CONING_ERROR
                FROM
                    SB_CONING_RUN RUN INNER JOIN
                    SB_INVOICE_ITEM ITEM ON
                        RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                    SB_INVOICE INVOICE ON
                        ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                    SB_INVOICE INVOICE2 ON
                        INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                        INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE  INNER JOIN
                    SB_INVOICE_ITEM ITEM2 ON
                        INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                        (   1 = 2
                            <cfoutput query="PER99">
                                <cfif PER99.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or ITEM2.SB_MBS_ITEM_NUMBER = '#PER99.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or ITEM2.SB_MBS_ITEM_NUMBER BETWEEN '#PER99.SB_MBS_ITEM_NUMBER#' and '#PER99.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                        ) AND
                        -- DO NOT COMPARE THE RECORD TO ITSELF
                        RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                        -- INCLUDE ONLY CLAIMED ITEMS
                        (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                        AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                WHERE
                            CONVERT(DATETIME, CONVERT(VARCHAR,run.SB_SERVICE_DATE,103)) = '#this_service_day#'
                  AND   (   1 = 2
                            <cfoutput query="PER99">
                                <cfif PER99.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or RUN.SB_ITEM_NUMBER = '#PER99.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or RUN.SB_ITEM_NUMBER BETWEEN '#PER99.SB_MBS_ITEM_NUMBER#' and '#PER99.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                        ) AND
                        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
            </cfquery>

            <cfif per99_services.RECORDCOUNT GT 0>
                <cfset error_code_list = "">
                <cfoutput query="PER99">
                    <cfif PER99.SB_MBS_ITEM_NUMBER_TO eq "">
                        <cfset error_code_list = trim(error_code_list & " " & PER99.SB_MBS_ITEM_NUMBER)>
                    <cfelse>
                        <cfset error_code_list = trim(error_code_list & " " & PER99.SB_MBS_ITEM_NUMBER & " - " & PER99.SB_MBS_ITEM_NUMBER_TO)>
                    </cfif>
                </cfoutput>

                <cfloop query="per99_services">
                    <cfset VARIABLES.ERROR_TEXT = #per99_services.SB_CONING_ERROR# & " Only one of items #error_code_list# can be claimed once per lifetime.">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="per99_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#per99_services.SB_CONING_ID#">
                    </cfquery>
                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

<cfset VARIABLES.ERROR_TEXT = "">


<!--- End of   Anaesthetic Billing Rules --->

<!--- Start of  Anaesthetic Derived Fee Items

Calculate the fee for item 25025 as follows:
50% of the total sum of all items in the ranges 20100-21997, 22900, 23010-24136, 25000-25015, 22001-22050.

Calculate the fee for item 25030 as follows:
50% of the total sum of all items in the ranges 25200-25205, 23010-24136, 25000-25015, 22001-22050

Calculate the fee for item 25050 as follows:
50% of the total sum of all items in the ranges 22060, 23010-24136, 25000-25015, 22001-22050, 22065-22075

Calculate the fee for item 25200 as follows:
$82.50 plus the total sum of all items in the range 23010-24136 and 25000-25020.

Calculate the fee for item 25205 as follows:
$82.50 plus the total sum of all items in the range 23010-24136 and 25000-25020.
 --->


    <!--- Calculate the fee for item 25200 as follows:
$82.50 plus the total sum of all items in the range 23010-24136 and 25000-25020.
DFAN4 processing needs to occur before DFAN2, as 25200 is a derived fee, and
can be used in the derivation of 25025.
--->
<cfloop index="DFARule" list="DFAN4,DFAN5">
    <cfif ListFind(required_rules,DFARule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFARule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDFAN2">
                    set dateformat YMD;
                    select  CR.SB_MBS_ITEM_NUMBER,
                            isnull(CR.SB_BASE_AMOUNT,IC.SB_MBS_ITEM_FEE) SB_BASE_AMOUNT
                    from    SB_CONING_RULE CR left outer join
                            SB_MBS_ITEM_COST IC on IC.SB_MBS_ITEM_NUMBER = CR.SB_BASED_ON_MBS_ITEM and
                                IC.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' >= IC.SB_MBS_COST_START and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' < isnull(IC.SB_MBS_COST_END,dateadd(year,100,getdate()))
                    where   CR.SB_CONING_RULE_ID = #this_rule_id#

                    set dateformat dmy;
                </cfquery>
                <cfif QDFAN2.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DFANItem2">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                    ORDER BY SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER
                </cfquery>
                <cfif DFANItem2.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for item 25025 as follows:
        50% of the total sum of all items in the ranges 20100-21997, 22900, 23010-24136, 25000-25015, 22001-22050. --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE2">
                    SET DATEFORMAT DMY;
                    WITH CONING_RECORDS
                    AS (
                        #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                    )
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR,
                        SB_SERVICE_DATE,
                        SB_DERIVED_NOGAP_PERCENT
                    FROM
                        CONING_RECORDS
                    WHERE
                        service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#' and
                        SB_ITEM_NUMBER = '#QDFAN2.SB_MBS_ITEM_NUMBER#'
                </cfquery>
<!--- If derived fee calculation with a no-gap percentage, and component does not
have a percentage specified and component is not derived, then the component has
the percentage built in to it, and must not be applied twice. Hence reduce component
by inverse of no gpa percentage, so when the percentage is reapplied it is only applied
once, not twice. --->
                <cfloop query="ANAE_DERIVED_FEE2">
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE2_TOTAL">
                        SELECT
                        <cfif ANAE_DERIVED_FEE2.SB_DERIVED_NOGAP_PERCENT eq "">
                            SUM(SB_ACTUAL_FEE) as total,
                        <cfelse>
                            SUM(
                            Case when SB_CONING_RUN.SB_DERIVED_NOGAP_PERCENT is null
                                  and SB_CONING_RUN.SB_SCHEDULE_FEE IS NOT NULL
                                 then SB_ACTUAL_FEE * 100 / #ANAE_DERIVED_FEE2.SB_DERIVED_NOGAP_PERCENT#
                                 else SB_ACTUAL_FEE end)
                            as total,
                        </cfif>
                            SUM(CASE WHEN 1=2
                        <cfoutput query="DFANItem2" startrow=1 maxrows=1>
                            <cfif DFANItem2.SB_MBS_ITEM_NUMBER_TO eq "">
                                OR SB_ITEM_NUMBER = '#DFANItem2.SB_MBS_ITEM_NUMBER#'
                                <cfset reqd_range = DFANItem2.SB_MBS_ITEM_NUMBER>
                            <cfelse>
                                OR SB_ITEM_NUMBER BETWEEN '#DFANItem2.SB_MBS_ITEM_NUMBER#' and '#DFANItem2.SB_MBS_ITEM_NUMBER_TO#'
                                <cfset reqd_range = DFANItem2.SB_MBS_ITEM_NUMBER & " - " & DFANItem2.SB_MBS_ITEM_NUMBER_TO>
                            </cfif>
                        </cfoutput>
                                    THEN 1 ELSE 0 END) AS FIRST_RANGE_COUNT
                        FROM
                            SB_CONING_RUN
                        WHERE
                             SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        and CONVERT(DATETIME, CONVERT(VARCHAR, SB_CONING_RUN.SB_SERVICE_DATE, 103)) = '#DateFormat(ANAE_DERIVED_FEE2.SB_SERVICE_DATE,"dd-mmm-yyyy")#'
                        AND (1 = 2
                        <cfoutput query="DFANItem2">
                            <cfif DFANItem2.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#DFANItem2.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#DFANItem2.SB_MBS_ITEM_NUMBER#' and '#DFANItem2.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                        )
                    </cfquery>


                    <cfif ANAE_DERIVED_FEE2_TOTAL.FIRST_RANGE_COUNT eq "" or ANAE_DERIVED_FEE2_TOTAL.FIRST_RANGE_COUNT eq "0">
                        <cfset VARIABLES.ERROR_TEXT = #ANAE_DERIVED_FEE2.SB_CONING_ERROR# & " Requires at least one item from #reqd_range#">
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
                    </cfif>
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE2_TOTAL_update">
                        UPDATE SB_CONING_RUN
                        <cfif ANAE_DERIVED_FEE2_TOTAL.FIRST_RANGE_COUNT eq "" or ANAE_DERIVED_FEE2_TOTAL.FIRST_RANGE_COUNT eq "0">
                            SET SB_ACTUAL_FEE = #qdfan2.SB_BASE_AMOUNT#,
                                SB_CONING_ERROR = '#ERROR_TEXT#',
                                SB_CONING_STATUS_CODE = 'ER'
                        <cfelse>
                            SET SB_ACTUAL_FEE = CEILING((#qdfan2.SB_BASE_AMOUNT# + #ANAE_DERIVED_FEE2_TOTAL.total#) / 0.05) * 0.05,
                                CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFARule#') <= 100
                                                        THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFARule#' ELSE '#DFARule#' END)
                                                        ELSE CONING_RULES_APPLIED END
                        </cfif>
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ANAE_DERIVED_FEE2.SB_CONING_ID#">
                    </cfquery>

                </cfloop>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>


<cfinvoke component="pbrc-ae.components.apply_coning" method="DRPRules" returnvariable="DRPRules">
<cfset derived_list = "DFAN1,DFAN2,DFAN3,AMP">
<cfoutput query="DRPRules">
    <cfif !listfindnocase(derived_list, #DRPRules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#DRPRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="DFARule" list="#derived_list#">
    <cfif ListFind(required_rules,DFARule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFARule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfif DFARule eq "AMP">
                    <cfset item_type = 'amputation'>
                <cfelse>
                    <cfset item_type = 'anaesthetic'>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDFAN">
                    select  SB_MBS_ITEM_NUMBER,
                            SB_RULE_PERCENT1
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QDFAN.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DFANItem">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif DFANItem.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for item 25025 as follows:
        50% of the total sum of all items in the ranges 20100-21997, 22900, 23010-24136, 25000-25015, 22001-22050. --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE1">
                    SET DATEFORMAT DMY;
                    WITH CONING_RECORDS
                    AS (
                        #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                    )
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR,
                        SB_SERVICE_DATE,
                        SB_DERIVED_NOGAP_PERCENT
                    FROM
                        CONING_RECORDS
                    WHERE
                        SB_ITEM_NUMBER = '#QDFAN.SB_MBS_ITEM_NUMBER#'
                        and service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                </cfquery>


<!--- If derived fee calculation with a no-gap percentage, and component does not
have a percentage specified and component is not derived, then the component has
the percentage built in to it, and must not be applied twice. Hence reduce component
by inverse of no gpa percentage, so when the percentage is reapplied it is only applied
once, not twice. --->

                <cfloop query="ANAE_DERIVED_FEE1">
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE1_TOTAL">
                        SELECT
                        <cfif ANAE_DERIVED_FEE1.SB_DERIVED_NOGAP_PERCENT eq "">
                            SUM(SB_ACTUAL_FEE) as total
                        <cfelse>
                            SUM(
                            Case when SB_CONING_RUN.SB_DERIVED_NOGAP_PERCENT is null
                                  and SB_CONING_RUN.SB_SCHEDULE_FEE IS NOT NULL
                                 then SB_ACTUAL_FEE * 100 / #ANAE_DERIVED_FEE1.SB_DERIVED_NOGAP_PERCENT#
                                 else SB_ACTUAL_FEE end)
                            as total
                        </cfif>
                        FROM
                            SB_CONING_RUN
                        WHERE
                             SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        AND DATEDIFF(DAY,  SB_CONING_RUN.SB_SERVICE_DATE, '#DateFormat(ANAE_DERIVED_FEE1.SB_SERVICE_DATE,"dd-mmm-yyyy")#' ) = 0
                        AND (1 = 2
                        <cfoutput query="DFANItem">
                            <cfif DFANItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#DFANItem.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#DFANItem.SB_MBS_ITEM_NUMBER#' and '#DFANItem.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                        )
                    </cfquery>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ANAE_DERIVED_FEE1_TOTAL_update">
                            UPDATE SB_CONING_RUN
                        <cfif ANAE_DERIVED_FEE1_TOTAL.total eq "" or ANAE_DERIVED_FEE1_TOTAL.total eq 0>
                                SET SB_ACTUAL_FEE = 0,
                                SB_CONING_ERROR = LTrim('#ANAE_DERIVED_FEE1.SB_CONING_ERROR#' + ' Item must be used in conjunction with other #item_type# items.'),
                                SB_CONING_STATUS_CODE = 'ER'
                        <cfelse>
                            SET SB_ACTUAL_FEE = CEILING((#ANAE_DERIVED_FEE1_TOTAL.total# * #QDFAN.SB_RULE_PERCENT1# / 100) / 0.05) * 0.05,
                                CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFARule#') <= 100
                                                        THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFARule#' ELSE '#DFARule#' END)
                                                        ELSE CONING_RULES_APPLIED END
                        </cfif>
                            WHERE
                                SB_CONING_ID = #ANAE_DERIVED_FEE1.SB_CONING_ID#
                    </cfquery>

                </cfloop>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

 <!---  End of  Anaesthetic Derived Fee Items--->

 <!--- Derived Fees - General

Item 00087  :
If sb_coning_qty <= 6 then $8.50 + (15.50 / sb_coning_qty) else 8.50 + (.70 * sb_coning_qty)

Item 00089  :
If sb_coning_qty <= 6 then $16.00 + (17.50 / sb_coning_qty) else 16.00 + (.70 * sb_coning_qty)

Item 00090  :
If sb_coning_qty <= 6 then $35.50 + (15.50 / sb_coning_qty) else 35.50 + (.70 * sb_coning_qty)

Item 00091  :
If sb_coning_qty <= 6 then $57.50 + (15.50 / sb_coning_qty) else 57.50 + (.70 * sb_coning_qty)


Item 51303  :
Add sum of all fees for items 30001 to 50426.
If <= 464.00, then flag as an error, status = 'ER', message is 'Item can only be claimed where cost of items 30001 to 50426
exceeds $464. Cost was only #sum of operations#'
Else fee = .2 * sum of operations

Item 51803  :
Add sum of all fees for items 51900 to 53460.
If <= 464.00, then flag as an error, status = 'ER', message is 'Item can only be claimed where cost of items 51900 to 53460
exceeds $464. Cost was only #sum of operations#'
Else fee = .2 * sum of operations
 --->

<!--- Get list of user defined rules, of type DFI and DFA
GP Derived Fee, based on a dollar amount and GP Derived Fee, based on another item --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="DFI" returnvariable="DFI">
<cfset derived_list = "DF87,DF89,DF90,DF91">
<cfoutput query="DFI">
    <cfif !listfindnocase(derived_list, #DFI.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#DFI.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="DFRule" list="#derived_list#">
    <cfif ListFind(required_rules,DFRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>
            <!--- Item 00087    :
        If sb_coning_qty <= 6 then $8.50 + (15.50 / sb_coning_qty) else 8.50 + (.70 * sb_coning_qty)--->

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDF">
                    set dateformat YMD;
                    select  CR.SB_MBS_ITEM_NUMBER,
                            isnull(CR.SB_BASE_AMOUNT,IC.SB_MBS_ITEM_FEE) SB_BASE_AMOUNT,
                            CR.SB_ADDITIONAL_PER_PAT1,
                            CR.SB_PATIENT_CUTOFF,
                            CR.SB_ADDITIONAL_PER_PAT2
                    from    SB_CONING_RULE CR left outer join
                            SB_MBS_ITEM_COST IC on IC.SB_MBS_ITEM_NUMBER = CR.SB_BASED_ON_MBS_ITEM and
                                IC.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' >= IC.SB_MBS_COST_START and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' < isnull(IC.SB_MBS_COST_END,dateadd(year,100,getdate()))
                    where   CR.SB_CONING_RULE_ID = #this_rule_id#

                    set dateformat dmy;
                </cfquery>
                <cfif QDF.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for the item  --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDF_Item">
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_QTY
                    FROM
                        SB_CONING_RUN
                    WHERE
                        SB_ITEM_NUMBER = '#QDF.SB_MBS_ITEM_NUMBER#'
                        and DATEDIFF(DAY,SB_SERVICE_DATE, '#this_service_day_mmm#') = 0
                        and SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                </cfquery>

                <cfif QDF_Item.RECORDCOUNT GT 0>

                    <cfoutput query="QDF_Item">
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDF_update">
                                UPDATE SB_CONING_RUN
                                <cfif QDF_Item.SB_CONING_QTY LE QDF.SB_PATIENT_CUTOFF>
                                    SET SB_ACTUAL_FEE = #CEILING((#qdf.SB_BASE_AMOUNT# + (#qdf.SB_ADDITIONAL_PER_PAT1# / #QDF_Item.SB_CONING_QTY#)) / 0.05) * 0.05#
                                <cfelse>
                                    SET SB_ACTUAL_FEE = #CEILING((#qdf.SB_BASE_AMOUNT# + (#qdf.SB_ADDITIONAL_PER_PAT2# * #QDF_Item.SB_CONING_QTY#)) / 0.05) * 0.05#
                                </cfif>,
                                        CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFRule#') <= 100
                                                                THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFRule#' ELSE '#DFRule#' END)
                                                                ELSE CONING_RULES_APPLIED END
                                WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#QDF_Item.SB_CONING_ID#">
                        </cfquery>
                    </cfoutput>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>
<!--- Get list of user defined rules, of type TIM
GP Derived Fee, based on a dollar amount and GP Derived Fee, based on another item,
plus time component.
e.g. The fee for 18216 plus 16.20 for every additional 15 mins of partthereof beyond the
first 60 mins of attendance.
 --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="TIM" returnvariable="TIM">
<cfset derived_list = "!">
<cfoutput query="TIM">
    <cfif !listfindnocase(derived_list, #TIM.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#TIM.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="DFRule" list="#derived_list#">
    <cfif ListFind(required_rules,DFRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QTIM">
                    set dateformat YMD;
                    select  CR.SB_MBS_ITEM_NUMBER,
                            isnull(CR.SB_BASE_AMOUNT,IC.SB_MBS_ITEM_FEE) SB_BASE_AMOUNT,
                            CR.SB_ADDITIONAL_PER_PAT1,
                            CR.SB_ADDITIONAL_MINUTES,
                            CR.SB_MINUTES_BEYOND
                    from    SB_CONING_RULE CR left outer join
                            SB_MBS_ITEM_COST IC on IC.SB_MBS_ITEM_NUMBER = CR.SB_BASED_ON_MBS_ITEM and
                                IC.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' >= IC.SB_MBS_COST_START and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' < isnull(IC.SB_MBS_COST_END,dateadd(year,100,getdate()))
                    where   CR.SB_CONING_RULE_ID = #this_rule_id#

                    set dateformat dmy;
                </cfquery>
                <cfif QTIM.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for the item  --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Qtim_Item">
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_DURATION
                    FROM
                        SB_CONING_RUN
                    WHERE
                        SB_ITEM_NUMBER = '#QTIM.SB_MBS_ITEM_NUMBER#'
                        and DATEDIFF(DAY,SB_SERVICE_DATE, '#this_service_day_mmm#') = 0
                        and SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                </cfquery>

                <cfif Qtim_Item.RECORDCOUNT GT 0>

                    <cfoutput query="Qtim_Item">
                        <cfset this_error = "N">
                        <cfif Qtim_Item.SB_CONING_DURATION eq "" or Qtim_Item.SB_CONING_DURATION LE QTIM.SB_MINUTES_BEYOND>
                            <cfset this_fee = QTIM.SB_BASE_AMOUNT>
                            <cfset this_error = "Y">
                        <cfelse>
                            <cfset this_qty = Ceiling((Qtim_Item.SB_CONING_DURATION - QTIM.SB_MINUTES_BEYOND) / QTIM.SB_ADDITIONAL_MINUTES)>
                            <cfset this_fee = QTIM.SB_BASE_AMOUNT + Ceiling((Qtim_Item.SB_CONING_DURATION - QTIM.SB_MINUTES_BEYOND) / QTIM.SB_ADDITIONAL_MINUTES) * QTIM.SB_ADDITIONAL_PER_PAT1>
                        </cfif>
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Qtim_update">
                                UPDATE SB_CONING_RUN
                                SET SB_ACTUAL_FEE = #this_fee#,
                                    CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFRule#') <= 100
                                                            THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFRule#' ELSE '#DFRule#' END)
                                                            ELSE CONING_RULES_APPLIED END,
                            <cfif this_error eq "Y">
                                    SB_CONING_ERROR = 'Time component must be greater than #QTIM.SB_MINUTES_BEYOND# minutes',
                                    SB_CONING_STATUS_CODE = 'ER'
                            <cfelse>
                                    SB_CONING_QTY = #this_qty#,
                                    SB_CONING_MSG_TO_HIC = 'Total time : #Qtim_Item.SB_CONING_DURATION# mins'
                            </cfif>
                                WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#Qtim_Item.SB_CONING_ID#">
                        </cfquery>
                    </cfoutput>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>
<!--- Get list of user defined rules, of type NUC
Nuclear Medicine Derived Fee, based on another item,
plus number of fields.
e.g. The fee for 15000 plus for each field in excess of 1, an amount of 14.50
 --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="NUC" returnvariable="NUC">
<cfset derived_list = "!">
<cfoutput query="NUC">
    <cfif !listfindnocase(derived_list, #NUC.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#NUC.SB_RULE_CODE#">
    </cfif>
</cfoutput>
<cfloop index="DFRule" list="#derived_list#">
    <cfif ListFind(required_rules,DFRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QNUC">
                    set dateformat YMD;
                    select  CR.SB_MBS_ITEM_NUMBER,
                            CR.SB_BASED_ON_MBS_ITEM,
                            isnull(CR.SB_BASE_AMOUNT,IC.SB_MBS_ITEM_FEE) SB_BASE_AMOUNT,
                            CR.SB_ADDITIONAL_PER_PAT1,
                            CR.SB_MINUTES_BEYOND
                    from    SB_CONING_RULE CR left outer join
                            SB_MBS_ITEM_COST IC on IC.SB_MBS_ITEM_NUMBER = CR.SB_BASED_ON_MBS_ITEM and
                                IC.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' >= IC.SB_MBS_COST_START and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' < isnull(IC.SB_MBS_COST_END,dateadd(year,100,getdate()))
                    where   CR.SB_CONING_RULE_ID = #this_rule_id#

                    set dateformat dmy;
                </cfquery>
                <cfif QNUC.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for the item

            Phil : 7-feb-2008

            The fee for rad onc items are generally defined as
            "The cost of item x plus $y for every field in excess of 1"
            So if
                x is base item number
                $x is the cost of the item
                y is the derived item number
                $f is the additional cost per field
                z is te number of fields
            then the cost of Y is $x + ($f * z)

            It is my understanding that the qty sent through with nuc med items is "the number of additional fields".
            Hence a qty of actually means one field in excess of 1. (total of 2 fields used).
            When claiming y, the cost of x is to be set to zero, and must also be claimed.
            The other trick is that the rounding for this calculation, particularly for medicare 85% is variable.

            Hence sites can have two options :
                a) Use these coning rules to define the item price, and adjust off any rounding errors.
                   In this scenario, the automated update from medicare will update the costs.
                b) Define the item cost in the item_cost table. The lookup includes the number of fields.
                   This gets around the potential rounding problems, but requires manual updating of the prices.

             --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QNUC_Item">
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_QTY,
                        SB_ACTUAL_FEE
                    FROM
                        SB_CONING_RUN
                    WHERE
                        SB_ITEM_NUMBER = '#QNUC.SB_MBS_ITEM_NUMBER#'
                        and DATEDIFF(DAY,SB_SERVICE_DATE, '#this_service_day_mmm#') = 0
                        and SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                </cfquery>
<!---
The database field SB_MINUTES_BEYOND for NUC items contains the "for each field in excess of".
 --->
                <cfif QNUC_Item.recordcount gt 0>
                    <cfif QNUC_Item.SB_ACTUAL_FEE eq 0>
                        <cfoutput query="QNUC_Item">
                            <cfset this_fee = QNUC.SB_BASE_AMOUNT + (QNUC_Item.SB_CONING_QTY * QNUC.SB_ADDITIONAL_PER_PAT1)>
                            <cfset additional_fields_fee = QNUC_Item.SB_CONING_QTY * QNUC.SB_ADDITIONAL_PER_PAT1>
                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QNUC_update">
                                    UPDATE SB_CONING_RUN
                                    SET SB_ACTUAL_FEE = #this_fee#,
                                        SB_FEE_FOR_FIELDS = #additional_fields_fee#,
                                        CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFRule#') <= 100
                                                            THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFRule#' ELSE '#DFRule#' END)
                                                            ELSE CONING_RULES_APPLIED END
                                    WHERE
                                    SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#QNUC_Item.SB_CONING_ID#">
                            </cfquery>
                        </cfoutput>
                    </cfif>

                </cfif>

            </cfif>
        </cfloop>
    </cfif>
</cfloop>

<!--- Item 51303    :
Add sum of all fees for items 30001 to 50426.
If <= 464.00, then flag as an error, status = 'ER', message is 'Item can only be claimed where cost of items 30001 to 50426
exceeds $464. Cost was only #sum of operations#'
Else fee = .2 * sum of operations--->
<cfloop index="DFARule" list="DFOP1,DFOP2">
    <cfif ListFind(required_rules,DFARule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq DFARule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDOP">
                    set dateformat YMD;
                    select  CR.SB_MBS_ITEM_NUMBER,
                            isnull(isnull(CR.SB_BASE_AMOUNT,IC.SB_MBS_ITEM_FEE),0) SB_BASE_AMOUNT
                    from    SB_CONING_RULE CR left outer join
                            SB_MBS_ITEM_COST IC on IC.SB_MBS_ITEM_NUMBER = CR.SB_BASED_ON_MBS_ITEM and
                                IC.SB_COST_TYPE_ID = #MBS100.SB_COST_TYPE_ID# and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' >= IC.SB_MBS_COST_START and
                                '#DateFormat(this_service_day_mmm, "yyyy-MM-dd")#' < isnull(IC.SB_MBS_COST_END,dateadd(year,100,getdate()))
                    where   CR.SB_CONING_RULE_ID = #this_rule_id#

                    set dateformat dmy;
                </cfquery>
                <cfif QDOP.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QDOPItem">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QDOPItem.recordcount eq 0>
                    The coning run requires the <cfoutput>#DFARule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

            <!--- Calculate the fee for item 25025 as follows:
        50% of the total sum of all items in the ranges 20100-21997, 22900, 23010-24136, 25000-25015, 22001-22050. --->
                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="OP_DERIVED_FEE1">
                    SET DATEFORMAT DMY;
                    WITH CONING_RECORDS
                    AS (
                        #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                    )
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR,
                        SB_SERVICE_DATE
                    FROM
                        CONING_RECORDS
                    WHERE
                    SB_ITEM_NUMBER = '#QDOP.SB_MBS_ITEM_NUMBER#'
                    and service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                </cfquery>

                <cfif OP_DERIVED_FEE1.RECORDCOUNT GT 0>
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="OP_DERIVED_FEE1_TOTAL">
                        SELECT
                            ISNULL(SUM(SB_ACTUAL_FEE),0) as total
                        FROM
                            SB_CONING_RUN
                        WHERE
                             SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                        AND DATEDIFF(DAY,  SB_CONING_RUN.SB_SERVICE_DATE, '#DateFormat(OP_DERIVED_FEE1.SB_SERVICE_DATE,"dd-mmm-yyyy")#' ) = 0
                        AND (1 = 2
                        <cfoutput query="QDOPItem">
                            <cfif QDOPItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                or SB_ITEM_NUMBER = '#QDOPItem.SB_MBS_ITEM_NUMBER#'
                            <cfelse>
                                or SB_ITEM_NUMBER BETWEEN '#QDOPItem.SB_MBS_ITEM_NUMBER#' and '#QDOPItem.SB_MBS_ITEM_NUMBER_TO#'
                            </cfif>
                        </cfoutput>
                        )
                    </cfquery>

                    <cfloop query="OP_DERIVED_FEE1">

                        <cfif OP_DERIVED_FEE1_TOTAL.total lte QDOP.SB_BASE_AMOUNT>
                            <cfif DFARule eq 'DFOP1'>
                                <cfset VARIABLES.ERROR_TEXT = Trim(OP_DERIVED_FEE1.SB_CONING_ERROR & " Item can only be claimed where cost of items 30001 to 50426 exceeds $#QDOP.SB_BASE_AMOUNT#. Cost was only $" & OP_DERIVED_FEE1_TOTAL.total)>
                            <cfelse>
                                <cfset VARIABLES.ERROR_TEXT = Trim(OP_DERIVED_FEE1.SB_CONING_ERROR & " Item can only be claimed where cost of items 51900 to 53460 exceeds $#QDOP.SB_BASE_AMOUNT#. Cost was only $" & OP_DERIVED_FEE1_TOTAL.total)>
                            </cfif>
                            <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                            <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DERIVED_FEES_5_error">
                                UPDATE SB_CONING_RUN
                                    SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                    SB_CONING_STATUS_CODE = 'ER'
                                WHERE
                                    SB_CONING_ID = #OP_DERIVED_FEE1.SB_CONING_ID#
                            </cfquery>
                        <cfelse>
                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="OP_DERIVED_FEE1_TOTAL_update">
                                UPDATE SB_CONING_RUN
                                <cfif OP_DERIVED_FEE1_TOTAL.total neq "">
                                    SET SB_ACTUAL_FEE = CEILING((#OP_DERIVED_FEE1_TOTAL.total# * #QDOP.SB_RULE_PERCENT1# / 100) / 0.05) * 0.05
                                <cfelse>
                                    SET SB_ACTUAL_FEE = 0
                                </cfif>,
                                    CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#DFARule#') <= 100
                                                            THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#DFARule#' ELSE '#DFARule#' END)
                                                            ELSE CONING_RULES_APPLIED END
                                WHERE
                                    SB_CONING_ID = #OP_DERIVED_FEE1.SB_CONING_ID#
                            </cfquery>
                        </cfif>

                    </cfloop>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

 <!--- End of Derived Fees - General  --->

 <!--- Start of Diagnostic Restrictions

Item 12203 and 12207
If patient age <= 18 years, then flag as an error, status = 'ER', message is 'Patient must be over 18 years old'.

Item 12210 and 12215
If patient age > 12 years, then flag as an error, status = 'ER', message is 'Patient must be less than 13 years old'.

Item 12213 and 12217
If patient age < 12 years or > 18, then flag as an error, status = 'ER', message is 'Patient must be between 12 and 18 years '.

Only one benefit can be claimed in a 24 month period for the following items: 12306, 12309, 12315 and 12318. It does not matter
which Dr performed the service. This rule applies to each item no separately, not as a group. E.g. It is OK for a patient to have
 a 12306 and 12309 in the same 2 year period. Where a subsequent item occurs within the 24 month period, flag it as an error,
 status = 'ER', message is 'Item can only be claimed once per 24 months. Item was previously claimed on dd-mmm-yyyy'

Only one benefit can be claimed in a 12 month period for the following items: 12312 and 12321. It does not matter
 which Dr performed the service. This rule applies to each item no separately, not as a group. E.g. It is OK for a patient to have
 a 12312 and 12321in the same 12 month period. Where a subsequent item occurs within the 12 month period, flag it as an error,
 status = 'ER', message is 'Item can only be claimed once per 12 months. Item was previously claimed on dd-mmm-yyyy'
 --->

    <!--- Item 12203 and 12207
    If patient age <= 18 years, then flag as an error, status = 'ER', message is 'Patient must be over 18 years old'. --->
<!--- Item 18350
If patient age <= 12 years, then flag as an error, status = 'ER', message is 'Patient must be over 12 years old'.

Item 18354 to 18358
If patient age < 2 years or > 17, then flag as an error, status = 'ER', message is 'Patient must be between 2 and 17 years '.

Age6 is different, in that patient cannot be between 1 and 70 years old.
 --->

<!--- Get list of user defined rules, of type AGE - Age restricted --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="AGERules" returnvariable="AGERules">
<cfset derived_list = "!">
<cfoutput query="AGERules">
    <cfif !listfindnocase(derived_list, #AGERules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#AGERules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="AgeRule" list="#derived_list#">
    <cfif ListFind(required_rules,AgeRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq AgeRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QAge">
                    select  SB_MIN_AGE,
                            SB_MAX_AGE
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QAge.recordcount eq 0>
                    The coning run requires the <cfoutput>#AgeRule#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="AgeItem">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif AgeItem.recordcount eq 0>
                    The coning run requires the <cfoutput>#AgeRule#</cfoutput> item records to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RESTRICTIONS_1">
                    SET DATEFORMAT DMY;
                    WITH CONING_RECORDS
                    AS (
                        #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                    )
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_PATIENT_AGE,
                        SB_CONING_ERROR
                    FROM
                        CONING_RECORDS
                    WHERE
                        service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                        and (   1 = 2
                            <cfoutput query="AgeItem">
                                <cfif AgeItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or SB_ITEM_NUMBER = '#AgeItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or SB_ITEM_NUMBER BETWEEN '#AgeItem.SB_MBS_ITEM_NUMBER#' and '#AgeItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                            )
                </cfquery>

                <cfif   DIAGNOSTIC_RESTRICTIONS_1.RECORDCOUNT GT 0>

                    <cfloop query="DIAGNOSTIC_RESTRICTIONS_1">
                        <cfif AgeRule eq 'AGE6'>

                            <cfif DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE GE QAge.SB_MIN_AGE
                              and DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE LT QAge.SB_MAX_AGE>

                                <cfset VARIABLES.ERROR_TEXT = #DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_ERROR# & " Patient cannot be between #QAge.SB_MIN_AGE# and #QAge.SB_MAX_AGE# years old. Patient is " & DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE & " years.">
                                <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                                <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RESTRICTIONS_1_error">
                                    UPDATE SB_CONING_RUN
                                        SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                        SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_ID#">
                                </cfquery>
                            </cfif>

                        <cfelse>

                            <cfif DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE LT QAge.SB_MIN_AGE
                               OR DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE GT QAge.SB_MAX_AGE>

                                <cfset VARIABLES.ERROR_TEXT = #DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_ERROR# & " Patient must be between #QAge.SB_MIN_AGE# and #QAge.SB_MAX_AGE# years old. Patient is " & DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_PATIENT_AGE & " years.">
                                <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                                <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DIAGNOSTIC_RESTRICTIONS_1_error">
                                    UPDATE SB_CONING_RUN
                                        SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                        SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                                    WHERE
                                        SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#DIAGNOSTIC_RESTRICTIONS_1.SB_CONING_ID#">
                                </cfquery>
                            </cfif>
                        </cfif>

                    </cfloop>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>


 <!--- End of Diagnostic Restrictions --->

 <!--- Therapeutic Procedures

Item 13870 cannot be claimed where the previous day (any dr) has a 13870 or 13873. Flag it as an error, status = 'ER',
 message is 'Item can only be claimed at the start of an ICU episode.'

Items 13870 and 13873 are mutually exclusive on the same day. Flag it as an error, status = 'ER', message is 'Items 13870 and 13873
cannot be claimed on the same day.'

Item 13876 cannot be claimed more than 4 times on the same day. Flag it as an error, status = 'ER', message is 'Item 13876 cannot be
claimed more than 4 times on the same day.'

Items 38215 to 38240 only one item in this range can be claimed on the same day. Flag as an error, status = 'ER', message is
'Items 38215 to 38240 are mutually exclusive on the same day '.

Item 38640 not payable in association with items 38656, 38643 or 38647 for same dr same day.
Flag as an error, status = 'ER', message is 'Item 38640 cannot be claimed with items 38656, 38643 or 38647 '.

Item 42770 has a maximum of 2 treatments in a 24 month period. If two already exist, then Flag as an error, status = 'ER',
 message is 'Item 42770 has already been used twice within the last 24 months. Please use 42771 instead.'.

Item 42782 has a maximum of 4 treatments in a 24 month period. If four already exist, then Flag as an error, status = 'ER',
 message is 'Item 42782 has already been used four times within the last 24 months. Please use 42783 instead.'.

Item 42785 has a maximum of 2 treatments in a 24 month period. If two already exist, then Flag as an error, status = 'ER',
message is 'Item 42785 has already been used twice within the last 24 months. Please use 42786 instead.'.

Item 42788 has a maximum of 2 treatments in a 24 month period. If two already exist, then Flag as an error, status = 'ER',
message is 'Item 42788 has already been used twice within the last 24 months. Please use 42789 instead.'.

Item 42791 has a maximum of 2 treatments in a 24 month period. If two already exist, then Flag as an error, status = 'ER',
message is 'Item 42791 has already been used twice within the last 24 months. Please use 42792 instead.'.

Only two benefits can be claimed in a 24 month period for the item: 42794. It does not matter which Dr performed the service.
Where a subsequent item occurs within the 24 month period, flag it as an error, status = 'ER', message is 'Item can only be claimed
 twice per 24 months. Item was previously claimed on dd-mmm-yyyy and dd-mmm-yyyy'.

Only four benefits can be claimed in a 24 month period for the item: 42797. It does not matter which Dr performed the service.
Where a subsequent item occurs within the 24 month period, flag it as an error, status = 'ER', message is 'Item can only be claimed four
times per 24 months. Item was previously claimed on dd-mmm-yyyy, dd-mmm-yyyy, dd-mmm-yyyy, dd-mmm-yyyy'.

Item 50124 has a maximum of 25 treatments in a 12 month period. If 25 already exist, then Flag as an error, status = 'ER',
message is 'Item 50124 has already been used 25 times within the last 12 months. Please use 50125 instead.'.

Items 48678 to 48690 must have an associated item in the range 48642 to 48675 for same dr same day. If not, then Flag it as an error,
status = 'ER', message is ' Items 48678 to 48690 must have an associated item in the range 48642 to 48675'
 --->
<cfif ListFind(required_rules,'ICU') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'ICU'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <!--- Item 13870 cannot be claimed where the previous day (any dr) has a 13870 or 13873. Flag it as an error, status = 'ER',
         message is 'Item can only be claimed at the start of an ICU episode.' --->
            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QICU">
                select  SB_MBS_ITEM_NUMBER
                from    SB_CONING_RULE
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif QICU.recordcount eq 0>
                The coning run requires the ICU record to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ICUItem">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif ICUItem.recordcount eq 0>
                The coning run requires the ICU item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="daysLimit">
                select  SB_EXCLUSIVE_DAYS
                from    SB_CONING_RULE
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ICU_13870">
                SELECT
                    RUN.SB_CONING_ID,
                    RUN.SB_CONING_ERROR
                FROM
                    SB_CONING_RUN RUN INNER JOIN
                    SB_INVOICE_ITEM ITEM ON
                        RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                    SB_INVOICE INVOICE ON
                        ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                    SB_INVOICE INVOICE2 ON
                        INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                        INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE  INNER JOIN
                    SB_INVOICE_ITEM ITEM2 ON
                        INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                        (   1 = 2
                            <cfoutput query="ICUItem">
                                <cfif ICUItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or ITEM2.SB_MBS_ITEM_NUMBER = '#ICUItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or ITEM2.SB_MBS_ITEM_NUMBER BETWEEN '#ICUItem.SB_MBS_ITEM_NUMBER#' and '#ICUItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                        ) AND
                        -- DO NOT COMPARE THE RECORD TO ITSELF
                        RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                        -- INCLUDE ONLY CLAIMED ITEMS
                        (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                        -- INCLUDE ONLY THOSE WHERE THE DIFFERENCE IN DAYS IS EQUAL TO ONE (HAPPENED YESTERDAY)
                        AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                        <cfif isdefined("daysLimit.SB_EXCLUSIVE_DAYS") and daysLimit.SB_EXCLUSIVE_DAYS neq "">
                            AND DATEDIFF(DAY,  ITEM2.SB_SERVICE_DATE, RUN.SB_SERVICE_DATE ) between 0 and #daysLimit.SB_EXCLUSIVE_DAYS#
                        </cfif>
                WHERE
                        RUN.SB_ITEM_NUMBER = '#QICU.SB_MBS_ITEM_NUMBER#'
                  and   CONVERT(DATETIME, CONVERT(VARCHAR,run.SB_SERVICE_DATE,103)) = '#this_service_day#'
                  and   SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
            </cfquery>

            <cfif ICU_13870.RECORDCOUNT NEQ 0>
                <cfloop query="ICU_13870">

                    <cfset VARIABLES.ERROR_TEXT = #ICU_13870.SB_CONING_ERROR# & " Item can only be claimed at the start of an ICU Episode, and not on same day as 13873">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ICU_13870_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ICU_13870.SB_CONING_ID#">
                    </cfquery>

                </cfloop>
            </cfif>
            <!---   Items 13870, 13873 only one item in this range can be claimed on the same day.
            Flag as an error, status = 'ER', message is     'Items 13870, 13873 are mutually exclusive on the same day '. --->

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ICU_DUP">
                SELECT
                    RUN.SB_CONING_ID,
                    RUN.SB_CONING_ERROR
                FROM
                    SB_CONING_RUN RUN INNER JOIN
                    SB_INVOICE_ITEM ITEM ON
                        RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                    SB_INVOICE INVOICE ON
                        ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                    SB_INVOICE INVOICE2 ON
                        INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                        INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE  INNER JOIN
                    SB_INVOICE_ITEM ITEM2 ON
                        INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                        (   1 = 2
                            <cfoutput query="ICUItem">
                                <cfif ICUItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or ITEM2.SB_MBS_ITEM_NUMBER = '#ICUItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or ITEM2.SB_MBS_ITEM_NUMBER BETWEEN '#ICUItem.SB_MBS_ITEM_NUMBER#' and '#ICUItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                        ) AND
                        -- DO NOT COMPARE THE RECORD TO ITSELF
                        RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                        -- INCLUDE ONLY CLAIMED ITEMS
                        (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                        AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                        -- INCLUDE ONLY THOSE WHERE THE DIFFERENCE IN DAYS IS EQUAL TO ONE (HAPPENED YESTERDAY)
                        AND DATEDIFF(DAY,  ITEM2.SB_SERVICE_DATE, RUN.SB_SERVICE_DATE )  = 0
                WHERE
                        CONVERT(DATETIME, CONVERT(VARCHAR,run.SB_SERVICE_DATE,103)) = '#this_service_day#'
                  and   (   1 = 2
                            <cfoutput query="ICUItem">
                                <cfif ICUItem.SB_MBS_ITEM_NUMBER_TO eq "">
                                    or RUN.SB_ITEM_NUMBER = '#ICUItem.SB_MBS_ITEM_NUMBER#'
                                <cfelse>
                                    or RUN.SB_ITEM_NUMBER BETWEEN '#ICUItem.SB_MBS_ITEM_NUMBER#' and '#ICUItem.SB_MBS_ITEM_NUMBER_TO#'
                                </cfif>
                            </cfoutput>
                        ) AND
                        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
            </cfquery>

            <cfif ICU_DUP.RECORDCOUNT GT 0>
                <cfset error_code_list = "">
                <cfoutput query="ICUItem">
                    <cfif ICUItem.SB_MBS_ITEM_NUMBER_TO eq "">
                        <cfset error_code_list = trim(error_code_list & " " & ICUItem.SB_MBS_ITEM_NUMBER)>
                    <cfelse>
                        <cfset error_code_list = trim(error_code_list & " " & ICUItem.SB_MBS_ITEM_NUMBER & " - " & ICUItem.SB_MBS_ITEM_NUMBER_TO)>
                    </cfif>
                </cfoutput>

                <cfloop query="ICU_DUP">
                    <cfset VARIABLES.ERROR_TEXT = #ICU_DUP.SB_CONING_ERROR# & " Items #error_code_list# are mutually exclusive on the same day.">
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="ICU_DUP_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#ICU_DUP.SB_CONING_ID#">
                    </cfquery>
                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>
    <!---   Items 38215 to 38240 only one item in this range can be claimed in the same episode.
    Flag as an error, status = 'ER', message is     'Items 38215 to 38240 are mutually exclusive on the same day '. --->

<!--- Get list of user defined rules, of type MEX - Mutually Exclusive --->
<!--- >> CACHED_QUERY << --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="MEXRules" returnvariable="MEXRules">
<cfset derived_list = "!">
<cfoutput query="MEXRules">
    <cfif !listfindnocase(derived_list, #MEXRules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#MEXRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="MexRule" list="#derived_list#">
    <cfif ListFind(required_rules,MexRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq MexRule>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MEX1Item">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif MEX1Item.recordcount eq 0>
                    The coning run requires the MEX1 item records to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="daysLimit">
                    select  SB_EXCLUSIVE_DAYS
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="THERAPEUTIC_05">
                    SELECT
                        RUN.SB_CONING_ID,
                        RUN.SB_CONING_ERROR
                    FROM
                        SB_CONING_RUN RUN INNER JOIN
                        SB_INVOICE_ITEM ITEM ON
                            RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                        SB_INVOICE INVOICE ON
                            ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                        SB_INVOICE INVOICE2 ON
                            INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                            INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE  and
                            INVOICE2.SB_EPISODE_NUMBER = RUN.SB_CONING_EPISODE
                            INNER JOIN
                        SB_INVOICE_ITEM ITEM2 ON
                            INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                            (   1 = 2
                                <cfoutput query="Mex1Item">
                                    <cfif Mex1Item.SB_MBS_ITEM_NUMBER_TO eq "">
                                        or ITEM2.SB_MBS_ITEM_NUMBER = '#Mex1Item.SB_MBS_ITEM_NUMBER#'
                                    <cfelse>
                                        or ITEM2.SB_MBS_ITEM_NUMBER BETWEEN '#Mex1Item.SB_MBS_ITEM_NUMBER#' and '#Mex1Item.SB_MBS_ITEM_NUMBER_TO#'
                                    </cfif>
                                </cfoutput>
                            ) AND
                            -- DO NOT COMPARE THE RECORD TO ITSELF
                            RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                            -- INCLUDE ONLY CLAIMED ITEMS
                            (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                            AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                    WHERE
                        CONVERT(DATETIME, CONVERT(VARCHAR,ITEM.SB_SERVICE_DATE,103)) = '#this_service_day#'
                        <cfif isdefined("daysLimit.SB_EXCLUSIVE_DAYS") and daysLimit.SB_EXCLUSIVE_DAYS neq "">
                            and ABS(DATEDIFF(DAY,CONVERT(DATETIME, CONVERT(VARCHAR,ITEM2.SB_SERVICE_DATE,103)),CONVERT(DATETIME, CONVERT(VARCHAR,ITEM.SB_SERVICE_DATE,103)))) < #daysLimit.SB_EXCLUSIVE_DAYS#
                        </cfif>

                          and   (   1 = 2
                                <cfoutput query="Mex1Item">
                                    <cfif Mex1Item.SB_MBS_ITEM_NUMBER_TO eq "">
                                        or RUN.SB_ITEM_NUMBER = '#Mex1Item.SB_MBS_ITEM_NUMBER#'
                                    <cfelse>
                                        or RUN.SB_ITEM_NUMBER BETWEEN '#Mex1Item.SB_MBS_ITEM_NUMBER#' and '#Mex1Item.SB_MBS_ITEM_NUMBER_TO#'
                                    </cfif>
                                </cfoutput>
                            ) AND
                            SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                </cfquery>

                <cfif THERAPEUTIC_05.RECORDCOUNT GT 0>
                    <cfset error_code_list = "">
                    <cfoutput query="MEX1Item">
                        <cfif MEX1Item.SB_MBS_ITEM_NUMBER_TO eq "">
                            <cfset error_code_list = trim(error_code_list & " " & MEX1Item.SB_MBS_ITEM_NUMBER)>
                        <cfelse>
                            <cfset error_code_list = trim(error_code_list & " " & MEX1Item.SB_MBS_ITEM_NUMBER & " - " & MEX1Item.SB_MBS_ITEM_NUMBER_TO)>
                        </cfif>
                    </cfoutput>

                    <cfloop query="THERAPEUTIC_05">
                        <cfset VARIABLES.ERROR_TEXT = #THERAPEUTIC_05.SB_CONING_ERROR# & " Items #error_code_list# are mutually exclusive on the same day.">
                        <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                        <cfquery  datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="THERAPEUTIC_05_error">
                            UPDATE SB_CONING_RUN
                                SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#THERAPEUTIC_05.SB_CONING_ID#">
                        </cfquery>
                    </cfloop>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

    <!---
    Repeat Rules - e.g. Item 42770 has a maximum of 2 treatments in a 24 month period.
    If two already exist, then Flag as an error, status = 'ER',
 message is 'Item 42770 has already been used twice within the last 24 months. Please use 42771 instead.'. --->
<cfinvoke component="pbrc-ae.components.apply_coning" method="REDRules" returnvariable="REDRules">
<cfset derived_list = "REP1,REP2,REP3,REP4,REP5,REP6">
<cfoutput query="REDRules">
    <cfif !listfindnocase(derived_list, #REDRules.SB_RULE_CODE#)>
        <cfset derived_list = derived_list & ",#REDRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>
<cfloop index="REPRULE" list="#derived_list#">
    <cfif ListFind(required_rules,REPRULE) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq REPRULE>
                <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
                <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
                <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QREP">
                    select  SB_MBS_ITEM_NUMBER,
                            SB_MAX_ITEMS_PER_PERIOD,
                            SB_DAYS_IN_PERIOD,
                            SB_REPLACEMENT_ITEM,
                            SB_RULE_TYPE
                    from    SB_CONING_RULE
                    where   SB_CONING_RULE_ID = #this_rule_id#
                </cfquery>
                <cfif QREP.recordcount eq 0>
                    The coning run requires the <cfoutput>#REPRULE#</cfoutput> record to be defined.
                    <cfabort>
                </cfif>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REP_Item">
                    SELECT
                        RUN.SB_CONING_ITEM_ID,
                        RUN.SB_ITEM_NUMBER,
                        INVOICE.SB_PROVIDER_NUMBER
                    FROM
                        SB_CONING_RUN RUN INNER JOIN
                        SB_INVOICE_ITEM ITEM ON
                            RUN.SB_CONING_ITEM_ID = ITEM.SB_INVOICE_ITEM_ID INNER JOIN
                        SB_INVOICE INVOICE ON
                            ITEM.SB_INVOICE_ID = INVOICE.SB_INVOICE_ID INNER JOIN
                        SB_INVOICE INVOICE2 ON
                            INVOICE.SB_PATIENT_MRN = INVOICE2.SB_PATIENT_MRN AND
                            INVOICE.SB_HL7_SOURCE = INVOICE2.SB_HL7_SOURCE INNER JOIN
                        SB_INVOICE_ITEM ITEM2 ON
                            INVOICE2.SB_INVOICE_ID = ITEM2.SB_INVOICE_ID AND
                            RUN.SB_ITEM_NUMBER = ITEM2.SB_MBS_ITEM_NUMBER AND
                            -- DO NOT COMPARE THE RECORD TO ITSELF
                            RUN.SB_CONING_ITEM_ID <> ITEM2.SB_INVOICE_ITEM_ID AND
                            -- INCLUDE ONLY CLAIMED ITEMS
                            (ITEM2.SB_ITEM_STATUS_CODE <> '98' AND ITEM2.SB_ITEM_STATUS_CODE <> '99')
                            AND (ITEM2.SB_ITEM_STATUS_CODE < '50' OR IsNull(ITEM2.SB_HIC_AMOUNT_PAID,0) + IsNull(ITEM2.SB_FUND_AMOUNT_PAID,0) > 0)
                            -- INCLUDE ONLY THOSE WHERE THE DIFFERENCE IN YEARS IS LESS THAN 1
                            AND DATEDIFF(DAY,  ITEM2.SB_SERVICE_DATE, RUN.SB_SERVICE_DATE ) BETWEEN 0 AND (#QREP.SB_DAYS_IN_PERIOD# - 1)

                    WHERE
                                RUN.SB_ITEM_NUMBER = '#QREP.SB_MBS_ITEM_NUMBER#'
                      and       CONVERT(DATETIME, CONVERT(VARCHAR,run.SB_SERVICE_DATE,103)) = '#this_service_day#'
                      and       SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
                      <cfif QREP.SB_RULE_TYPE eq "RED">
                        and     INVOICE.SB_PROVIDER_NUMBER = INVOICE2.SB_PROVIDER_NUMBER
                      </cfif>
                    GROUP BY
                        RUN.SB_CONING_ITEM_ID,
                        RUN.SB_ITEM_NUMBER,
                        INVOICE.SB_PROVIDER_NUMBER
                    HAVING COUNT(ITEM2.SB_INVOICE_ITEM_ID) >= #QREP.SB_MAX_ITEMS_PER_PERIOD#
                </cfquery>

                <cfif REP_Item.RECORDCOUNT NEQ 0>
                    <cfloop query="REP_Item">

                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REP_CHECK">
                            SELECT
                                SB_CONING_ID,
                                SB_CONING_ERROR
                            FROM
                                SB_CONING_RUN
                            WHERE
                                SB_CONING_ITEM_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#REP_ITEM.SB_CONING_ITEM_ID#">
                        </cfquery>

                        <cfloop query="REP_CHECK">

                            <cfif QREP.SB_RULE_TYPE eq "RED">
                                <cfset VARIABLES.ERROR_TEXT = REP_CHECK.SB_CONING_ERROR & " Item #QREP.SB_MBS_ITEM_NUMBER# has already been used #QREP.SB_MAX_ITEMS_PER_PERIOD# times for provider #REP_Item.SB_PROVIDER_NUMBER# within the last #QREP.SB_DAYS_IN_PERIOD# days. Please use #QREP.SB_REPLACEMENT_ITEM# instead.">
                            <cfelse>
                                <cfset VARIABLES.ERROR_TEXT = REP_CHECK.SB_CONING_ERROR & " Item #QREP.SB_MBS_ITEM_NUMBER# has already been used #QREP.SB_MAX_ITEMS_PER_PERIOD# times within the last #QREP.SB_DAYS_IN_PERIOD# days. Please use #QREP.SB_REPLACEMENT_ITEM# instead.">
                            </cfif>
                            <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MRI_error">
                                UPDATE SB_CONING_RUN
                                    SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                                    SB_CONING_STATUS_CODE = 'ER'
                                WHERE
                                    SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#REP_CHECK.SB_CONING_ID#">
                            </cfquery>
                        </cfloop>
                    </cfloop>
                </cfif>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>

    <!---   Items 48678 to 48690 must have an associated item in the range 48642 to 48675 for same dr same day. If not, then Flag it as an error,
    status = 'ER', message is ' Items 48678 to 48690 must have an associated item in the range 48642 to 48675' --->

<cfif ListFind(required_rules,'REQ1') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'REQ1'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ1">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif REQ1.recordcount eq 0>
                The coning run requires the REQ1 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ2">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'REQ2'
            </cfquery>
            <cfif REQ2.recordcount eq 0>
                The coning run requires the REQ2 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQUIRED_RANGE_1">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_ITEM_NUMBER,
                    SB_CONING_ERROR
                FROM
                    CONING_RECORDS
                WHERE   service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                  and ( 1 = 2
                <cfoutput query="REQ1">
                    <cfif REQ1.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#REQ1.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#REQ1.SB_MBS_ITEM_NUMBER#' and '#REQ1.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQUIRED_RANGE_2">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_ITEM_NUMBER,
                    SB_CONING_ERROR
                FROM
                    CONING_RECORDS
                WHERE   service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                  and ( 1 = 2
                <cfoutput query="REQ2">
                    <cfif REQ2.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#REQ2.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#REQ2.SB_MBS_ITEM_NUMBER#' and '#REQ2.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfset VARIABLES.ERROR_TEXT = "">

            <!--- Record an error for range 1 --->
            <cfif REQUIRED_RANGE_1.RECORDCOUNT GT 0 AND REQUIRED_RANGE_2.RECORDCOUNT EQ 0>
                <cfset error_code_list = "">
                <cfoutput query="REQ2">
                    <cfif REQ2.SB_MBS_ITEM_NUMBER_TO eq "">
                        <cfset error_code_list = trim(error_code_list & " " & REQ2.SB_MBS_ITEM_NUMBER)>
                    <cfelse>
                        <cfset error_code_list = trim(error_code_list & " " & REQ2.SB_MBS_ITEM_NUMBER & " - " & REQ2.SB_MBS_ITEM_NUMBER_TO)>
                    </cfif>
                </cfoutput>
                <cfloop query="REQUIRED_RANGE_1">

                    <!---
                    SRT, 20-12-2006 added rule name to error description
                    --->
                    <cfset VARIABLES.ERROR_TEXT = #REQUIRED_RANGE_1.SB_CONING_ERROR# & " Item requires an item in the range #error_code_list# Rule REQ1" >
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ_RANGE_1_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#REQUIRED_RANGE_1.SB_CONING_ID#">
                    </cfquery>

                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

<!--- Items in req3 must have an item in req4.
At setup, req3 had 25020 and req4 had 22060 --->
<cfif ListFind(required_rules,'REQ3') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'REQ3'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ3">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>
            <cfif REQ3.recordcount eq 0>
                The coning run requires the REQ3 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ4">
                select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                        SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
                from    SB_CONING_RULE_ITEM,
                        SB_CONING_RULE
                where   '#this_service_day_mmm#' between SB_RULE_START_DATE
                                                 and IsNull(SB_RULE_END_DATE,'31-dec-3000')
                  and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                  and   SB_RULE_CODE = 'REQ4'
            </cfquery>
            <cfif REQ4.recordcount eq 0>
                The coning run requires the REQ4 item records to be defined.
                <cfabort>
            </cfif>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQUIRED_RANGE_3">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_ITEM_NUMBER,
                    SB_CONING_ERROR
                FROM
                    CONING_RECORDS
                WHERE   service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                  and ( 1 = 2
                <cfoutput query="REQ3">
                    <cfif REQ3.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#REQ3.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#REQ3.SB_MBS_ITEM_NUMBER#' and '#REQ3.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQUIRED_RANGE_4">
                SET DATEFORMAT DMY;
                WITH CONING_RECORDS
                AS (
                    #preserveSingleQuotes(CONING_RECORDS_QUERY)#
                )
                SELECT
                    SB_CONING_ID,
                    SB_ITEM_NUMBER,
                    SB_CONING_ERROR
                FROM
                    CONING_RECORDS
                WHERE   service_day = '#DateFormat(this_service_day_mmm, "dd-mmm-yyyy")#'
                  and ( 1 = 2
                <cfoutput query="REQ4">
                    <cfif REQ4.SB_MBS_ITEM_NUMBER_TO eq "">
                        or SB_ITEM_NUMBER = '#REQ4.SB_MBS_ITEM_NUMBER#'
                    <cfelse>
                        or SB_ITEM_NUMBER BETWEEN '#REQ4.SB_MBS_ITEM_NUMBER#' and '#REQ4.SB_MBS_ITEM_NUMBER_TO#'
                    </cfif>
                </cfoutput>)
            </cfquery>

            <cfset VARIABLES.ERROR_TEXT = "">

            <!--- Record an error for range 1 --->
            <cfif REQUIRED_RANGE_3.RECORDCOUNT GT 0 AND REQUIRED_RANGE_4.RECORDCOUNT EQ 0>
                <cfset error_code_list = "">
                <cfoutput query="REQ4">
                    <cfif REQ4.SB_MBS_ITEM_NUMBER_TO eq "">
                        <cfset error_code_list = trim(error_code_list & " " & REQ4.SB_MBS_ITEM_NUMBER)>
                    <cfelse>
                        <cfset error_code_list = trim(error_code_list & " " & REQ4.SB_MBS_ITEM_NUMBER & " - " & REQ4.SB_MBS_ITEM_NUMBER_TO)>
                    </cfif>
                </cfoutput>
                <cfloop query="REQUIRED_RANGE_3">

                    <cfset VARIABLES.ERROR_TEXT = #REQUIRED_RANGE_3.SB_CONING_ERROR# & " Item requires an item in the range #error_code_list# Rule REQ3" >
                    <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>

                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="REQ_RANGE_3_error">
                        UPDATE SB_CONING_RUN
                            SET SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000),
                            SB_CONING_STATUS_CODE = <cfqueryparam cfsqltype="cf_sql_varchar" value="ER">
                        WHERE
                            SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#REQUIRED_RANGE_3.SB_CONING_ID#">
                    </cfquery>

                </cfloop>
            </cfif>
        </cfif>
    </cfloop>
</cfif>

 <!--- End of Therapeutic procedures --->

<!--- Start of Outpatient Reduction --->

<!---   For bulk bill, apply rule OUTP, which states Outpatient fee reduced by $60
if total exceeds $400.
Rule is applied for same provider, same day. Highest item is reduced.
 --->

<cfif ListFind(required_rules,'OUTP') gt 0>
    <cfloop query="Find_Coning">
        <cfif Find_Coning.SB_RULE_CODE eq 'OUTP'>
            <cfset this_service_day = DateFormat(find_coning.SERVICE_DAY,"dd/mm/yyyy")>
            <cfset this_service_day_mmm = DateFormat(find_coning.SERVICE_DAY,"dd-mmm-yyyy")>
            <cfset this_rule_id = find_coning.SB_CONING_RULE_ID>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="OUTP">
                select  SB_CONSULT_FEE_1,
                        SB_REDUCTION_1,
                        SB_CONING_RULE_ID
                from    SB_CONING_RULE
                where   SB_CONING_RULE_ID = #this_rule_id#
            </cfquery>

            <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Multiple_Outp">
                SELECT
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) AS SERVICE_DAY,
                    SB_CONING_PROVIDER
                FROM    SB_CONING_RUN
                WHERE   SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                and
                    CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day#' and
                    (SB_CONING_BILL_MECH = 'B' or SB_CONING_BILL_MECH = 'BM')
                GROUP BY CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)),
                         SB_CONING_PROVIDER
                HAVING SUM(SB_CONING_RUN.SB_SCHEDULE_FEE) > #OUTP.SB_CONSULT_FEE_1#
            </cfquery>

            <!--- Loop through the Multiple_Outp record set. --->
            <cfloop query="Multiple_Outp">

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Reduce_Outp">
                    SELECT TOP 1
                        SB_CONING_ID
                    FROM SB_CONING_RUN
                    WHERE SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
                      AND CONVERT(DATETIME, CONVERT(VARCHAR, SB_SERVICE_DATE,103)) = '#this_service_day#'
                      AND SB_CONING_PROVIDER = '#Multiple_Outp.SB_CONING_PROVIDER#'
                    ORDER BY SB_ACTUAL_FEE DESC
                </cfquery>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Reduce_Out">
                    UPDATE SB_CONING_RUN
                    SET SB_ACTUAL_FEE = SB_SCHEDULE_FEE - #OUTP.SB_REDUCTION_1#,
                        CONING_RULES_APPLIED = CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + 'OUTP') <= 100
                                                THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + 'OUTP' ELSE 'OUTP' END)
                                                ELSE CONING_RULES_APPLIED END
                    WHERE SB_CONING_ID = #Reduce_Outp.SB_CONING_ID#
                </cfquery>
            </cfloop>

        </cfif>
    </cfloop>
</cfif>

<!--- End Of Multiple Operations Forumala --->

<!--- End of outpatient reduction --->


 <!--- Start of Clinbical Letter Required

NOTE : Originally there was code here to control clinical letters. It was moved to sbmt77_act.
Functionality in sbmt77_act.cfm includes the following...

        "Check if item requires a clinical letter. If so, put it on a separate invoice, and attach a flag
        stating "Clinical Letter from Dr required before payment can be made", and ensure billing mechanism
        is "DD" - Direct to Debtor."

 --->

<!--- End of Clinical Letter Required --->

<!--- Find any records that do not have a cost (and must have one) and update the coning_record with an error message --->
<cfset ct_zero_cost_items = "">
<cfif check_dup_proc.RECORDCOUNT NEQ 0>
    <cfloop index="CTItem" list="CTSPA,CTSPB,CTSPC,CTSPD,RSA,RSB">
        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="CTSPZEROITEM">
            select  DISTINCT
                    SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                    SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO
            from    SB_CONING_RULE_ITEM,
                    SB_CONING_RULE
            where   SB_RULE_START_DATE < '#coning_hist_date#'
              and   (SB_RULE_END_DATE IS NULL OR SB_RULE_END_DATE > '#coning_hist_date#')
              and   SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
              and   SB_RULE_CODE = '#CTItem#'
        </cfquery>
        <cfoutput query="CTSPZEROITEM">
            <cfif CTSPZEROITEM.SB_MBS_ITEM_NUMBER_TO eq "">
                <cfset ct_zero_cost_items = ct_zero_cost_items &
                    " and SB_ITEM_NUMBER <> '#CTSPZEROITEM.SB_MBS_ITEM_NUMBER#'">
            <cfelse>
                <cfset ct_zero_cost_items = ct_zero_cost_items &
                    " and SB_ITEM_NUMBER NOT BETWEEN '#CTSPZEROITEM.SB_MBS_ITEM_NUMBER#' and '#CTSPZEROITEM.SB_MBS_ITEM_NUMBER_TO#'">
            </cfif>
        </cfoutput>
    </cfloop>

    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="MISSING_COST_CRITERIA2">
         SELECT SB_CONING_ID, SB_CONING_ITEM_ID,SB_ACTUAL_FEE
         FROM   SB_CONING_RUN
         WHERE  SB_CONING_RUN_NO = '#VARIABLES.unique_id#'
           AND  SB_CONING_ERROR IS NULL
           AND  (SB_ACTUAL_FEE IS NULL OR SB_ACTUAL_FEE <= 0)
           #PreserveSingleQuotes(ct_zero_cost_items)#
    </cfquery>


     <cfoutput query="MISSING_COST_CRITERIA2">

         <cfset ARGUMENTS.coning_error_count = ARGUMENTS.coning_error_count + 1>
         <cfset VARIABLES.ERROR_TEXT = 'A valid cost could not be determined.'>
        <!---
            Radiation Oncology can have zero cost items that need to be sent to medicare as part of the claim.
            These will have an equipment number against them.
            Only flag the zero cost error where there is no equipment number.
        --->
         <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_CONING_RECORDS">
         UPDATE SB_CONING_RUN
            SET
                SB_CONING_STATUS_CODE = 'ER',
                SB_CONING_ERROR = LEFT('#VARIABLES.ERROR_TEXT#',3000)
            FROM
                SB_CONING_RUN
            inner join SB_INVOICE_ITEM
                on SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID = SB_CONING_RUN.SB_CONING_ITEM_ID
            WHERE
                SB_CONING_RUN.SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#MISSING_COST_CRITERIA2.SB_CONING_ID#">
                AND ISNULL(SB_INVOICE_ITEM.SB_EQUIP_NO ,'') = ''
                and NOT SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER BETWEEN '15211' AND '15600'
         </cfquery>
     </cfoutput>
</cfif>


<cfinvoke component="pbrc-ae.components.apply_coning" method="TICRules" returnvariable="TICRules">
<cfset derived_list = "!">
<cfoutput query="TICRules">
    <cfif !listfindnocase(derived_list, #TICRules.SB_RULE_CODE#)>
        <cfset derived_list &= ",#TICRules.SB_RULE_CODE#">
    </cfif>
</cfoutput>

<cfloop index="TICRule" list="#derived_list#">
    <cfif ListFind(required_rules,TICRule) gt 0>
        <cfloop query="Find_Coning">
            <cfif Find_Coning.SB_RULE_CODE eq TICRule>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QTIC">
                    select
                        SB_ADDITIONAL_MINUTES,
                        SB_MINUTES_BEYOND,
                        isnull(SB_MAX_REDUCTION,0) as SB_MAX_REDUCTION,
                        SB_RULE_PERCENT1,
                        SB_DEDUCTION_OP
                    from
                        SB_CONING_RULE
                    where
                        SB_CONING_RULE_ID = #find_coning.SB_CONING_RULE_ID#
                </cfquery>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="TicItemRange">
                    select  SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER,
                            isnull(SB_CONING_RULE_ITEM.SB_MBS_ITEM_NUMBER_TO,'') SB_MBS_ITEM_NUMBER_TO
                    from    SB_CONING_RULE_ITEM inner join
                            SB_CONING_RULE on
                                SB_CONING_RULE_ITEM.SB_CONING_RULE_ID = SB_CONING_RULE.SB_CONING_RULE_ID
                    where   SB_RULE_CODE = '#TICRule#'
                </cfquery>

                <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="TicItems">
                    SELECT
                        SB_CONING_ID,
                        SB_CONING_ERROR
                    FROM
                        SB_CONING_RUN
                    WHERE
                        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#"> and (
                            1 = 2
                            <cfoutput query="TicItemRange">
                                or SB_ITEM_NUMBER BETWEEN '#TicItemRange.SB_MBS_ITEM_NUMBER#' and isnull(cast(nullif('#TicItemRange.SB_MBS_ITEM_NUMBER_TO#','') as varchar),'#TicItemRange.SB_MBS_ITEM_NUMBER#')
                            </cfoutput>
                        )
                </cfquery>

                <cfloop query="TicItems">

                    <!--- Calculate the fee for the item  --->
                    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="Qtic_Item">
                        SELECT
                            SB_CONING_ID,
                            SB_CONING_DURATION,
                            CURRENT_DEDUCTIONS,
                            SB_SCHEDULE_FEE
                        FROM
                            SB_CONING_RUN
                        WHERE
                            SB_CONING_ID = #TicItems.SB_CONING_ID#
                    </cfquery>

                    <cfif Qtic_Item.RECORDCOUNT GT 0 and Qtic_Item.SB_CONING_DURATION neq "" and Qtic_Item.SB_CONING_DURATION gt 0>
                        <cfif Qtic_Item.SB_CONING_DURATION eq "" or Qtic_Item.SB_CONING_DURATION LE QTIC.SB_MINUTES_BEYOND>
                            <cfset base_fee = QTIC.SB_BASE_AMOUNT>
                        <cfelse>
                            <cfset this_qty = Ceiling((Qtic_Item.SB_CONING_DURATION - QTIC.SB_MINUTES_BEYOND) / QTIC.SB_ADDITIONAL_MINUTES)>
                            <cfif QTIC.SB_DEDUCTION_OP eq "O">
                                <cfset base_fee = (Qtic_Item.SB_SCHEDULE_FEE + Ceiling((Qtic_Item.SB_CONING_DURATION - QTIC.SB_MINUTES_BEYOND) / QTIC.SB_ADDITIONAL_MINUTES) * Qtic_Item.SB_SCHEDULE_FEE) - Qtic_Item.CURRENT_DEDUCTIONS>
                            <cfelseif QTIC.SB_DEDUCTION_OP eq "P">
                                <cfset base_fee = Qtic_Item.SB_SCHEDULE_FEE + Ceiling((Qtic_Item.SB_CONING_DURATION - QTIC.SB_MINUTES_BEYOND) / QTIC.SB_ADDITIONAL_MINUTES) * (Qtic_Item.SB_SCHEDULE_FEE - Qtic_Item.CURRENT_DEDUCTIONS)>
                            <cfelse>
                                <cfset base_fee = Qtic_Item.SB_SCHEDULE_FEE + Ceiling((Qtic_Item.SB_CONING_DURATION - QTIC.SB_MINUTES_BEYOND) / QTIC.SB_ADDITIONAL_MINUTES) * Qtic_Item.SB_SCHEDULE_FEE>
                            </cfif>
                            <cfset max_red_fee = 0>
                            <cfif QTIC.SB_MAX_REDUCTION gt 0>
                                <cfset max_red_fee = base_fee - QTIC.SB_MAX_REDUCTION>
                            </cfif>
                        </cfif>
                        <cfset rulePercent = QTIC.SB_RULE_PERCENT1/100>
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QTIC_update">
                            declare @percentFee numeric(18,2) = CEILING ((#base_fee# * #rulePercent# ) / 0.05) * 0.05;
                            declare @maxRedFee numeric(18,2) = #max_red_fee#;

                            UPDATE SB_CONING_RUN
                            SET SB_ACTUAL_FEE = case when @maxRedFee > @percentFee then @maxRedFee else @percentFee end,
                                CONING_RULES_APPLIED =  CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'') + ',' + '#TICRule#') <= 100
                                                        THEN (CASE WHEN LEN(ISNULL(CONING_RULES_APPLIED,'')) > 0 THEN CONING_RULES_APPLIED + ',' + '#TICRule#' ELSE '#TICRule#' END)
                                                        ELSE CONING_RULES_APPLIED END
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#QTIC_Item.SB_CONING_ID#">
                        </cfquery>
                    <cfelse>
                        <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="QTIC_update">
                            UPDATE SB_CONING_RUN
                            SET
                                SB_CONING_ERROR = CASE WHEN SB_CONING_ERROR is not null and SB_CONING_ERROR <> '' then  LEFT(SB_CONING_ERROR + ' A valid duration was not set against service, could not evaluate coning rule: #TICRule#.',3000) else 'A valid duration was not set against service, could not evaluate coning rule: #TICRule# .' end,
                                SB_CONING_STATUS_CODE = 'ER'
                            WHERE
                                SB_CONING_ID = <cfqueryparam cfsqltype="cf_sql_numeric" value="#QTIC_Item.SB_CONING_ID#">
                        </cfquery>
                    </cfif>
                </cfloop>
            </cfif>
        </cfloop>
    </cfif>
</cfloop>



<!--- There was an occurrence where items had an invoice date, but a status of info missing.
(HICOnline or DVA).
In this case, the invoice total needs updating after the invoice items.
However, the trigger to update the invoice total is if invoice date is null.
Hence before update of items, use item status to update invoice amount to zero,
then include zero invoices amounts in the criteria to update the invoice amount --->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_SB_INVOICE_ITEM">
    UPDATE SB_INVOICE
    SET
        SB_INVOICE_TOTAL_AMT = 0,
        SB_INVOICE.SB_UPDATED_BY =
            <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
            <cfelse>
                'pbrc-ae:ACL'
            </cfif>,
        SB_INVOICE.SB_UPDATE_DATE = getDate(),
        SB_UPDATED_FROM = 'apply_coning_logic UPDATE_SB_INVOICE_ITEM'
    FROM
        SB_CONING_RUN
    inner join SB_INVOICE_ITEM
        on SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID = SB_CONING_RUN.SB_CONING_ITEM_ID
    inner join SB_INVOICE
        on SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID
    where
        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
</cfquery>

<!--- Update Invoice Item with the price by decided by the coning procedures .......  --->

<!--- The SQL command Round(x, decimal places) is equivalent to cf Fix()
Any costs are assumed to be GST exclusive.
If GST inclusive, use the following instead:
        SB_INVOICE_COST = ISNULL(SB_ACTUAL_FEE, 0),
        SB_GST_AMOUNT_CLAIMED = ISNULL(SB_ACTUAL_FEE, 0) - Round((ISNULL(SB_ACTUAL_FEE, 0) * (100.0 / (SB_GST_PERCENT + 100))),2),

If derived fee for medicare bulk bill, use 85% of cost.

    Then had a problem with 15230 to 15272, where by medicare rounded down instead of to nearest when calculating the 85%
    Hence the following code:
--->

<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE_SB_INVOICE_ITEM">
    UPDATE SB_INVOICE_ITEM
    SET
        SB_INVOICE_COST =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            Case when SB_CONING_RUN.SB_SCHEDULE_FEE IS NULL
                  and SB_CONING_RUN.SB_CONING_BILL_MECH in ('B','BM')
                  and SB_CONING_RUN.SB_ITEM_NUMBER BETWEEN '15230' AND '15272'
                 then CEILING ((SB_ACTUAL_FEE * .85 ) / 0.05) * 0.05
                 when SB_CONING_RUN.SB_SCHEDULE_FEE IS NULL
                  and SB_CONING_RUN.SB_CONING_BILL_MECH in ('B','BM')
                 then CEILING ((SB_ACTUAL_FEE *.85 ) / 0.05) * 0.05
                 else CEILING((ISNULL(SB_ACTUAL_FEE,0) * ISNULL(SB_DERIVED_NOGAP_PERCENT,100) / 100.0 * (SB_GST_PERCENT + 100.0) / 100.0) / 0.05) * 0.05
            end
        ELSE
            SB_INVOICE_COST
        END,

        SB_GST_AMOUNT_CLAIMED =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            ISNULL(SB_ACTUAL_FEE,0) * SB_GST_PERCENT / 100.0
        ELSE
            SB_GST_AMOUNT_CLAIMED
        END,
        SB_OUTPAT_ERROR = Left(SB_CONING_ERROR,300),
        SB_FIN_CLASS_CODE = SB_CONING_FIN_CLASS,

        SB_CONING_MESSAGE_TO_HIC    = Left(Case     when SB_CONING_BILL_MECH = 'DV' AND
                                        (SB_CONING_NOT_DUP_SERVICE = 'Y' OR SB_CONING_MULTIPLE_OVERRIDE = 'Y')
                                    then  RIGHT(CONVERT(VARCHAR, SB_CONING_RUN.sb_service_date ),7) + ' ' + SB_CONING_MSG_TO_HIC
                                    else  SB_CONING_MSG_TO_HIC end,50),
        SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
        SB_ITEM_QTY = SB_CONING_QTY,
        SB_ITEM_STATUS_CODE = Case when SB_CONING_STATUS_CODE = 'ER' then 'ER' else SB_ITEM_STATUS_CODE end,
        SB_INVOICE_COST_75 =
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL THEN
            (
            CASE WHEN SB_SCHEDULE_FEE <> SB_ACTUAL_FEE OR (SB_ACTUAL_FEE_75 IS NULL ) THEN
                CEILING((SB_ACTUAL_FEE * 0.75 ) / 0.05) * 0.05
            ELSE
                SB_ACTUAL_FEE_75
            END
            )
        ELSE
            SB_INVOICE_COST_75
        END,
        SB_INVOICE_ITEM.SB_UPDATED_BY =
            <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
            <cfelse>
                'pbrc-ae:ACL'
            </cfif>,
        SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
        SB_UPDATED_FROM = 'apply_coning_logic UPDATE_SB_INVOICE_ITEM',
        SB_INVOICE_ITEM.CONING_RULES_APPLIED = SB_CONING_RUN.CONING_RULES_APPLIED
    FROM
        SB_CONING_RUN INNER JOIN
        SB_INVOICE_ITEM ON
            SB_CONING_RUN.SB_CONING_ITEM_ID = SB_INVOICE_ITEM.SB_INVOICE_ITEM_ID INNER JOIN
        SB_INVOICE ON
            SB_INVOICE_ITEM.SB_INVOICE_ID = SB_INVOICE.SB_INVOICE_ID
    where
        SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
</cfquery>

<cfinvoke component="pbrc-ae.components.item" method="Bulid_Message_To_Medicare" returnvariable="none">
    <cfinvokeargument name="Coning_Run" value="#VARIABLES.unique_id#">
</cfinvoke>

<cfquery name="CheckPharmacy" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
    SELECT  SB_INVOICE.SB_INVOICE_ID
    FROM
            SB_PATIENT_EPISODE
            INNER JOIN SB_INVOICE
            ON SB_PATIENT_EPISODE.SB_EPISODE_NUMBER = SB_INVOICE.SB_EPISODE_NUMBER
    WHERE
            SB_INVOICE.SB_INVOICE_DATE IS NULL
        AND SB_PATIENT_EPISODE.SB_EPISODE_TYPE_CODE = 'P'
        AND SB_PATIENT_EPISODE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#">
        AND SB_PATIENT_EPISODE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
        AND SB_INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
</cfquery>

<cfif CheckPharmacy.recordcount gt 0>
    <!--- Pharmacy Episodes are not represented by coning because they do not have episode_fin_class records --->
    <!--- so....... we go and get the price from the table itself... --->
    <cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE">
        UPDATE SB_INVOICE_ITEM
        SET
        SB_INVOICE_COST =
        CASE WHEN  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'Y'
            THEN SB_INVOICE_COST
        ELSE
        CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL AND (SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL ) THEN
            CEILING ((SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY +
            (
                (SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY) *  ( GST.SB_GST_PERCENT / 100.00  )
            ) ) / 0.05) * 0.05
        ELSE
            ISNULL(SB_INVOICE_ITEM.SB_INVOICE_COST ,0)
            END
        END,
        SB_GST_AMOUNT_CLAIMED =
        CASE WHEN  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'Y'
            THEN SB_GST_AMOUNT_CLAIMED
        ELSE
            (SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY) *  ( GST.SB_GST_PERCENT / 100.00 )
        END,
        SB_OUTPAT_ERROR =
        Case
            when IsNull(CASE WHEN SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL THEN SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE ELSE SB_INVOICE_ITEM.SB_INVOICE_COST END,0) = 0
            then 'Pharmacy item cost could not be determined'
            else SB_OUTPAT_ERROR
          End,
        SB_ITEM_STATUS_CODE = Case
            when IsNull(CASE WHEN SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL THEN SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE ELSE SB_INVOICE_ITEM.SB_INVOICE_COST END,0) = 0
            then 'er'
            else SB_ITEM_STATUS_CODE
          End,
        SB_FIN_CLASS_CODE = '#VARIABLES.finClassUtil.getPharmacyFinClassCode()#',
        SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
        SB_INVOICE_ITEM.SB_UPDATED_BY =
            <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
            <cfelse>
                'pbrc-ae:ACL'
            </cfif>,
        SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
        SB_UPDATED_FROM = 'apply_coning_logic UPDATE'
        FROM
            SB_PATIENT_EPISODE   INNER JOIN
            SB_INVOICE   ON
                SB_PATIENT_EPISODE.SB_EPISODE_NUMBER = SB_INVOICE.SB_EPISODE_NUMBER  INNER JOIN
            SB_INVOICE_ITEM   ON
                SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID LEFT OUTER JOIN
            SB_MBS_ITEM_COST  with (nolock) ON
                SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER = SB_MBS_ITEM_COST.SB_MBS_ITEM_NUMBER AND
                SB_INVOICE_ITEM.SB_SERVICE_DATE BETWEEN SB_MBS_ITEM_COST.SB_MBS_COST_START AND ISNULL(SB_MBS_ITEM_COST.SB_MBS_COST_END, GETDATE()) LEFT OUTER JOIN
            SB_COST_TYPE  with (nolock) ON
                SB_MBS_ITEM_COST.SB_COST_TYPE_ID = SB_COST_TYPE.SB_COST_TYPE_ID AND
                SB_COST_TYPE.SB_COST_TYPE_DESC = 'MISC' AND
                SB_COST_TYPE.SB_CURRENT = 'Y'  LEFT OUTER JOIN
            dbo.SB_GST_CATEGORY GST ON
                SB_INVOICE_ITEM.SB_GST_CAT_ID = GST.SB_GST_CAT_ID
        WHERE
            SB_INVOICE.SB_INVOICE_DATE IS NULL AND
            SB_PATIENT_EPISODE.SB_EPISODE_TYPE_CODE = 'P' AND
            SB_PATIENT_EPISODE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#"> and
            SB_PATIENT_EPISODE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
            AND   SB_INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
    </cfquery>
</cfif>

<!--- Birps --->
<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="UPDATE">
    UPDATE SB_INVOICE_ITEM
    SET
    SB_INVOICE_COST =
    CASE WHEN SB_INVOICE.SB_INVOICE_DATE IS NULL AND (SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL ) THEN
        CEILING ((SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY +
        (
            (SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY) *  ( GST.SB_GST_PERCENT / 100.00  )
        )) / 0.05) * 0.05
    ELSE
        ISNULL(SB_INVOICE_ITEM.SB_INVOICE_COST ,0)
    END,
    SB_GST_AMOUNT_CLAIMED =
    (SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE * SB_INVOICE_ITEM.SB_ITEM_QTY) *  ( GST.SB_GST_PERCENT / 100.00 )  ,
    SB_OUTPAT_ERROR =
    Case
        when IsNull(CASE WHEN SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL THEN SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE ELSE SB_INVOICE_ITEM.SB_INVOICE_COST END,0) = 0
        then 'Pharmacy item cost could not be determined'
        else SB_OUTPAT_ERROR
      End,
    SB_ITEM_STATUS_CODE = Case
        when IsNull(CASE WHEN SB_INVOICE_ITEM.SB_PRICE_OVERRIDE = 'N' OR  SB_INVOICE_ITEM.SB_PRICE_OVERRIDE IS NULL THEN SB_MBS_ITEM_COST.SB_MBS_ITEM_FEE ELSE SB_INVOICE_ITEM.SB_INVOICE_COST END,0) = 0
        then 'er'
        else SB_ITEM_STATUS_CODE
      End,
    SB_ORIG_MBS_ITEM_NUMBER = ISNULL(SB_INVOICE_ITEM.SB_ORIG_MBS_ITEM_NUMBER,SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER),
        SB_INVOICE_ITEM.SB_UPDATED_BY =
            <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
            <cfelse>
                'pbrc-ae:ACL'
            </cfif>,
        SB_INVOICE_ITEM.SB_UPDATE_DATE = getDate(),
        SB_UPDATED_FROM = 'apply_coning_logic UPDATE'
    FROM
        SB_PATIENT_EPISODE   INNER JOIN
        SB_INVOICE   ON
            SB_PATIENT_EPISODE.SB_EPISODE_NUMBER = SB_INVOICE.SB_EPISODE_NUMBER  INNER JOIN
        SB_INVOICE_ITEM   ON
            SB_INVOICE.SB_INVOICE_ID = SB_INVOICE_ITEM.SB_INVOICE_ID LEFT OUTER JOIN
        SB_MBS_ITEM_COST  with (nolock) ON
            SB_INVOICE_ITEM.SB_MBS_ITEM_NUMBER = SB_MBS_ITEM_COST.SB_MBS_ITEM_NUMBER AND
            SB_INVOICE_ITEM.SB_SERVICE_DATE BETWEEN SB_MBS_ITEM_COST.SB_MBS_COST_START AND ISNULL(SB_MBS_ITEM_COST.SB_MBS_COST_END, GETDATE()) LEFT OUTER JOIN
        SB_COST_TYPE  with (nolock) ON
            SB_MBS_ITEM_COST.SB_COST_TYPE_ID = SB_COST_TYPE.SB_COST_TYPE_ID AND
            SB_COST_TYPE.SB_COST_TYPE_DESC = 'ctp' AND
            SB_COST_TYPE.SB_CURRENT = 'Y' LEFT OUTER JOIN
        dbo.SB_GST_CATEGORY GST ON
            SB_INVOICE_ITEM.SB_GST_CAT_ID = GST.SB_GST_CAT_ID
    WHERE
        SB_INVOICE.SB_INVOICE_DATE IS NULL AND
        SB_PATIENT_EPISODE.SB_EPISODE_TYPE_CODE = 'B' AND
        SB_PATIENT_EPISODE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#"> and
        SB_PATIENT_EPISODE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
        AND SB_INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
</cfquery>
<!--- Update the invoice totals. --->
<cfquery name="Update_Inv" datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#">
        Update SB_INVOICE
        set     SB_INVOICE_TOTAL_AMT = IsNull((Select Sum(SB_INVOICE_COST)
                            from SB_INVOICE_ITEM
                            where SB_INVOICE_ID = sb_invoice.SB_INVOICE_ID
                              and SB_ITEM_STATUS_CODE <> '99'),0),
                SB_INVOICE_TOTAL_GST = IsNull((Select Sum(SB_GST_AMOUNT_CLAIMED)
                            from SB_INVOICE_ITEM
                            where SB_INVOICE_ID = sb_invoice.SB_INVOICE_ID
                              and SB_ITEM_STATUS_CODE <> '99'),0),
                SB_UPDATED_BY =
                    <cfif isDefined("SESSION.SB_LOGIN_CODE")>
                        <cfqueryparam cfsqltype="cf_sql_varchar" value="#SESSION.SB_LOGIN_CODE#">
                    <cfelse>
                        'pbrc-ae:ACL'
                    </cfif>,
                SB_UPDATE_DATE = getDate(),
                SB_UPDATED_FROM = 'apply_coning_logic Update_Inv'
        WHERE
        (SB_INVOICE.SB_INVOICE_DATE IS NULL or SB_INVOICE_TOTAL_AMT = 0) AND
        SB_INVOICE.SB_PATIENT_MRN = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.mrn#"> and
        SB_INVOICE.SB_HL7_SOURCE = <cfqueryparam cfsqltype="cf_sql_varchar" value="#ARGUMENTS.source#">
        AND   SB_INVOICE.SB_INVOICE_ID in (#ARGUMENTS.sb_invoice_id#)
</cfquery>

<cfquery datasource="#Application.DSNdatasource#" username="#Application.DSNuser#" password="#Application.DSNpass#" name="DELETE">
     DELETE
     FROM   SB_CONING_RUN
     WHERE SB_CONING_RUN_NO = <cfqueryparam cfsqltype="cf_sql_varchar" value="#VARIABLES.unique_id#">
</cfquery>


<!--- Set the chart of account code on the invoice, or flag as an error if not found.
If an error is found with the chart of account, it will mask any other errors until it is fixed.
This is because it is both tricky and time consuming within CF_allocate_chart_of_acc to retrieve the existing
memo field that contains the error prior to updating it. If this is really a problem, the easiest way around would
be to convert sb_invoice_item.SB_OUTPAT_ERROR to be VA(300) or so.
However this may impact on eclipse processing, and the maximum length of eclipse errors needs
to be investigated. (If I recall correctly, they can be quite big). --->

    <cfinvoke component="allocate_chart_of_acc" method="allocate" returnvariable="none">
        <cfinvokeargument name="alloc_coac_mrn" value="#ARGUMENTS.mrn#">
        <cfinvokeargument name="alloc_coac_hl7_source" value="#ARGUMENTS.source#">
        <cfinvokeargument name="imaging_install" value="0">
    </cfinvoke>
</cfsilent>