[Event Request][W1][Table][246][Requisition Line] Add OnBeforeValidateQuantity and OnAfterValidateQuantity events to field 8 "Quantity"

[vveljovicaptean]

Why do you need this change?

Table 246 "Requisition Line", field 8 Quantity, OnValidate. The first two statements of the
trigger assign the field and its base quantity unconditionally, before any publisher is reached:

Quantity := UOMMgt.RoundAndValidateQty(Quantity, "Qty. Rounding Precision", FieldCaption(Quantity));
"Quantity (Base)" := UOMMgt.CalcBaseQty(...);

The first publisher in the trigger, OnValidateQuantityOnBeforeGetDirectCost, sits inside
if Type = Type::Item then and is only reached after both statements have already run. Both
UOMMgt.RoundAndValidateQty and UOMMgt.CalcBaseQty raise rounding-precision errors, so for the
lines we care about the trigger errors out before any extension code can run at all. For line
types other than Item the trigger contains no publisher whatsoever.

Our solution plans supply for produce/manufacturing items whose base quantity is derived from our
own unit-of-measure model, and whose rounding-precision validation has to run at a different point
in the sequence and against a different precision than the base app applies. We need to substitute
those two statements for our own line types while leaving standard behaviour untouched for every
other line, and we need one point at the end of the trigger to run our follow-up validation in the
correct order.

Precedent: the sibling field in the same table already has this

Field 5408 "Quantity (Base)" carries exactly the pattern being requested:

trigger OnValidate()
var
    IsHandled: Boolean;
begin
    IsHandled := false;
    OnBeforeValidateQuantityBase(Rec, IsHandled, xRec, CurrFieldNo, CurrentFieldNo);
    if IsHandled then
        exit;

    TestProdOrderNo();
    TestField("Qty. per Unit of Measure", 1);
    Validate(Quantity, "Quantity (Base)");
end;

Quantity and "Quantity (Base)" are two entry points into the same calculation and only one of
them is extensible. This request makes the pair consistent.

Describe the request

Two new integration events on Table 246 "Requisition Line", field 8 Quantity, OnValidate.
Please add them to main and to the latest release branch.

Proposed publisher location

Object: Table 246 "Requisition Line"
Trigger: field(8; Quantity; Decimal) — OnValidate
Placement: OnBeforeValidateQuantity as the first statement of the trigger, ahead of
UOMMgt.RoundAndValidateQty; OnAfterValidateQuantity as the last statement, outside
if Type = Type::Item then, so it is raised for every line type.
Publisher declarations keep the alphabetical order already used in this object:
OnAfterValidateQuantity between OnAfterValidateFields and
OnAfterValidateShortcutDimCode; OnBeforeValidateQuantity immediately before
OnBeforeValidateQuantityBase.

**AFTER

        trigger OnValidate()
        var
            IsHandled: Boolean;
        begin
            IsHandled := false;
            OnBeforeValidateQuantity(Rec, IsHandled, xRec, CurrFieldNo, CurrentFieldNo);
            if IsHandled then
                exit;

            Quantity := UOMMgt.RoundAndValidateQty(Quantity, "Qty. Rounding Precision", FieldCaption(Quantity));

            "Quantity (Base)" :=
                UOMMgt.CalcBaseQty(
                    "No.", "Variant Code", "Unit of Measure Code", Quantity, "Qty. per Unit of Measure",
                    "Qty. Rounding Precision (Base)", FieldCaption("Qty. Rounding Precision"), FieldCaption(Quantity),
                    FieldCaption("Quantity (Base)"));

            if Type = Type::Item then begin
                // unchanged
            end;

            OnAfterValidateQuantity(Rec, xRec, CurrFieldNo, CurrentFieldNo);
        end;

Proposed publishers

[IntegrationEvent(false, false)]
local procedure OnBeforeValidateQuantity(var RequisitionLine: Record "Requisition Line"; var IsHandled: Boolean; xRequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

[IntegrationEvent(false, false)]
local procedure OnAfterValidateQuantity(var RequisitionLine: Record "Requisition Line"; xRequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

Provide an implementation (optional)

• I will provide the implementation for this extensibility request

[github-actions]

Hi vveljovicaptean,

Thank you for your extensibility request. To help us process it efficiently, please update the issue to include the required information.

📚 Extensibility Guidelines

Missing Information:

• Alternatives evaluated: Please describe which existing events or extensibility patterns you evaluated for this scenario and why they are insufficient for your needs.
• Performance considerations: Please provide the expected execution frequency of this validation path and any expected performance impact of adding these events.
• Data sensitivity review: Please confirm whether this change would expose any sensitive or private data, and if not, state that explicitly.
• Multi-extension interaction: Please explain how conflicts should be handled if multiple extensions subscribe to the new IsHandled event or rely on this validation sequence.

Please update the issue with the missing details. We'll automatically re-analyze once updated.

Note

Automatically generated by the Triage Agent — advisory only. An engineer will review before any action is taken.

Tip

Is the triage result incorrect? Reply with /not-accurate and briefly explain what was wrong. Your feedback improves future responses.

[vveljovicaptean]

The platform events, OnBeforeValidateEvent and OnAfterValidateEvent, have no IsHandled, and neither exposes CurrentFieldNo. They do pass CurrFieldNo. The section also walks the prototype you would otherwise be asked about: pre-conditioning the value in the before-event suppresses the error, but cost and reservations still validate against the base-app "Quantity (Base)", and SetRemaningQuantity() is local, so you cannot finish the correction from outside.

The two in-trigger publishers both sit inside if Type = Type::Item then, after the statements that fail.

One level down in UOM Mgt, RoundAndValidateQty publishes nothing. Its only hook, OnBeforeQtyRndPrecision, takes a bare Decimal with no record context, and OnAfterCalcBaseQtyPerUnitOfMeasure fires after QuantityImbalanceErr with no more context than that. Both are global, so we cannot scope either one to your lines. The remaining two rungs are tableextension modify(Quantity) and the interface in UOM Mgt.

Performance rests on real call sites. PlanningLineManagement.Codeunit.al. O(planning lines) per regenerative plan, and the others are GetActionMessages, CalculateSubcontracts, CapabletoPromise, the "Quantity (Base)" cascade, and interactive entry. With nobody subscribed, the trigger costs an empty local call and touches no data.

The answer states the data sensitivity outright, then backs it. The table is CustomerContent and carries one EUII field, 5590 "User ID", which already travels through three existing publishers in the same object, so the request opens no new surface. GlobalVarAccess = false keeps exposure down to the signature.

On multiple extensions, the After event is additive, and the Before event uses the standard IsHandled contract: claim only your own lines and never reset the flag to false, so the first claimer wins whatever the subscriber order is.

we only need this two events that we proposed:

[IntegrationEvent(false, false)]
local procedure OnBeforeValidateQuantity(var RequisitionLine: Record "Requisition Line"; var IsHandled: Boolean; xRequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

[IntegrationEvent(false, false)]
local procedure OnAfterValidateQuantity(var RequisitionLine: Record "Requisition Line"; xRequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

[github-actions]

Hi vveljovicaptean,

Thank you for your extensibility request. To help us process it efficiently, please update the issue to include the required information.

📚 Extensibility Guidelines

Missing Information:

• Existing event vs. new event requirement: Please confirm whether extending the existing OnValidateQuantityOnBeforeGetDirectCost event would be sufficient, or whether you specifically need a new OnBeforeValidateQuantity at the very start of the trigger because the current event runs only inside if Type = Type::Item then and after RoundAndValidateQty/CalcBaseQty.
• xRec requirement confirmation: Please confirm that the requested xRequisitionLine parameter is required in this table-trigger context and explain which previous-record values your scenario needs from it.

Please update the issue with the missing details. We'll automatically re-analyze once updated.

Note

Automatically generated by the Triage Agent — advisory only. An engineer will review before any action is taken.

Tip

Is the triage result incorrect? Reply with /not-accurate and briefly explain what was wrong. Your feedback improves future responses.

[vveljovicaptean]

Hello,

Existing event vs. new event requirement:
OnValidateQuantityOnBeforeGetDirectCost is not sufficient, and widening its signature would not help either. It is raised inside if Type = Type::Item then, after UOMMgt.RoundAndValidateQty and UOMMgt.CalcBaseQty have already assigned Quantity and "Quantity (Base)", and after either of them may have raised a rounding-precision error. By the time it fires, the two statements we need to replace have already run.

For our procure item lines we calculate "Net Quantity (Base)" in a different way, so the base-app calculation has to be skipped, not corrected afterwards. Skipping it requires an IsHandled flag on a publisher placed as the first statement of the trigger. That is what OnBeforeValidateQuantity provides, and no existing publisher in this trigger sits at that position.

OnAfterValidateQuantity is needed at the other end of the trigger for the same ordering reason: our follow-up validation has to run after the standard logic and for line types other than Item, and the trigger currently ends without any publisher outside the Type::Item branch.

xRec requirement confirmation
xRequisitionLine is not required. We included it because it was convenient while writing the request, not because our scenario reads any previous-record value. Please drop it from both signatures:

[IntegrationEvent(false, false)]
local procedure OnBeforeValidateQuantity(var RequisitionLine: Record "Requisition Line"; var IsHandled: Boolean; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

[IntegrationEvent(false, false)]
local procedure OnAfterValidateQuantity(var RequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
begin
end;

[github-actions]

Hi vveljovicaptean,

Thank you for your extensibility request. To help us process it efficiently, please update the issue to include the required information.

📚 Extensibility Guidelines

Missing Information:

• Implementation approach confirmation: The requested before/after events in Table 246 "Requisition Line" field 8 Quantity OnValidate are feasible, but the new IsHandled event would bypass a larger cohesive block of trigger logic rather than a very small inline calculation. This should likely be implemented by extracting the current Quantity OnValidate body into a dedicated local procedure, raising OnBeforeValidateQuantity(var RequisitionLine; var IsHandled; CallingFieldNo; GlobalCurrentFieldNo) before that procedure call, and raising OnAfterValidateQuantity(var RequisitionLine; CallingFieldNo; GlobalCurrentFieldNo) after it so the after-event always runs for all line types. Please confirm whether this extraction-based implementation should be included in the request, or explain why keeping the larger bypass inline is preferred for your scenario.

Please update the issue with the missing details. We'll automatically re-analyze once updated.

Note

Automatically generated by the Triage Agent — advisory only. An engineer will review before any action is taken.

Tip

Is the triage result incorrect? Reply with /not-accurate and briefly explain what was wrong. Your feedback improves future responses.

[vveljovicaptean]

Hello,

i confirm proposed approach.

and the issue body is now updated with the extraction-based implementation.

The current Quantity OnValidate body moves unchanged into a new local procedure ValidateQuantity(). The trigger raises OnBeforeValidateQuantity(Rec, IsHandled, CurrFieldNo, CurrentFieldNo) before the call and OnAfterValidateQuantity(Rec, CurrFieldNo, CurrentFieldNo) after it, so the after event runs for all line types. We do not want the larger inline bypass.

[github-actions]

✅ Analysis complete - ready for further processing

---

Implementation:

Add OnBeforeValidateQuantity and OnAfterValidateQuantity integration events to Table 246 Requisition Line field 8 Quantity OnValidate, using an extraction-based implementation where the current trigger body moves unchanged into a new local ValidateQuantity() procedure. Raise the before-event as the first statement of the trigger with IsHandled support, call ValidateQuantity() only when not handled, and raise the after-event after the call so it runs for all line types.

Location in OnValidate() trigger and new local procedure:

        field(8; Quantity; Decimal)
        {
            AutoFormatType = 0;
            Caption = 'Quantity';
            ToolTip = 'Specifies the number of units of the item.';
            DecimalPlaces = 0 : 5;

            trigger OnValidate()
            var
                IsHandled: Boolean;
            begin
                IsHandled := false;
                OnBeforeValidateQuantity(Rec, IsHandled, CurrFieldNo, CurrentFieldNo);
                if not IsHandled then
                    ValidateQuantity();

                OnAfterValidateQuantity(Rec, CurrFieldNo, CurrentFieldNo);
            end;
        }

    local procedure ValidateQuantity()
    begin
        Quantity := UOMMgt.RoundAndValidateQty(Quantity, "Qty. Rounding Precision", FieldCaption(Quantity));

        "Quantity (Base)" :=
            UOMMgt.CalcBaseQty(
                "No.", "Variant Code", "Unit of Measure Code", Quantity, "Qty. per Unit of Measure",
                "Qty. Rounding Precision (Base)", FieldCaption("Qty. Rounding Precision"), FieldCaption(Quantity),
                FieldCaption("Quantity (Base)"));

        if Type = Type::Item then begin
            OnValidateQuantityOnBeforeGetDirectCost(Rec, xRec, CurrFieldNo);
            GetDirectCost(FieldNo(Quantity));
            SetRemaningQuantity();

            if (CurrFieldNo = FieldNo(Quantity)) or (CurrentFieldNo = FieldNo(Quantity)) then
                SetActionMessage();

            "Net Quantity (Base)" := (Quantity - "Original Quantity") * "Qty. per Unit of Measure";

            OnValidateQuantityOnBeforeUnitCost(Rec, CurrFieldNo, CurrentFieldNo);
            Validate("Unit Cost");
        end;
    end;

Event Publisher (add at the end of the codeunit with other events):

    [IntegrationEvent(false, false)]
    local procedure OnBeforeValidateQuantity(var RequisitionLine: Record "Requisition Line"; var IsHandled: Boolean; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnAfterValidateQuantity(var RequisitionLine: Record "Requisition Line"; CallingFieldNo: Integer; GlobalCurrentFieldNo: Integer)
    begin
    end;

---

File: RequisitionLine.Table.al

Note

Automatically generated by the Triage Agent — advisory only. An engineer will review before any action is taken.

Tip

Is the triage result incorrect? Reply with /not-accurate and briefly explain what was wrong. Your feedback improves future responses.