Skip to main content

Sales price agreement created

Fires when posting a trade-agreement journal creates a new sales price: a posted journal line inserts a sales-price trade agreement (a PriceDiscTable row with relation Price (sales)) for an agreement - account, item, currency, unit, quantity break and inventory dimensions - that had no sales price in effect on the new price's From date. Downstream systems can use it to publish new customer-specific, price-group or all-customer prices to storefronts, CPQ tools or external pricing engines as soon as they are committed.

Event classMGCLatticeTradeAgreementPriceCreatedBusinessEvent
Contract classMGCLatticeTradeAgreementPriceBusinessEventContract
CategorySales orders
ModuleModuleAxapta::SalesOrder
Label IDsTradeAgrPriceCreatedName / TradeAgrPriceCreatedDesc
TriggerPriceDiscAdmCheckPost.createOrUpdatePriceDiscTableRecords() -> a posted sales-price journal line inserted a row for an agreement with no sales price in effect on its From date

Trigger / Hook​

Which path raises which event​

The six sales price agreement events share one payload contract and are told apart by changeType / changeTypeName. All six are limited to sales price agreements - PriceDiscTable rows whose relation is Price (sales) (PriceType::PriceSales); purchase prices and discount agreements never raise them, and journal lines with another relation are ignored. Below, agreement means a row's account code and account relation, item code and item relation, currency, unit, quantity break (from quantity) and inventory dimensions; the dates and the amount are not part of it.

EventRaised byFires when
Sales price agreement created (this event)Posting a trade-agreement journalA posted journal line inserted a sales price for an agreement that had no sales price in effect on the new price's From date
Sales price agreement modifiedPosting a trade-agreement journalA posted journal line that references an existing sales price changed at least one of its values
Sales price agreement supersededPosting a trade-agreement journalA posted journal line inserted a sales price for an agreement that already had a sales price in effect on the new price's From date
Sales price agreement deletedPriceDiscTable.delete(), and posting a journal line marked for deletionA sales price is deleted
Sales price agreement effectiveEffectivity batch (background process, every legal entity)A sales price's From date is after the batch's position and on or before the run date
Sales price agreement expiredEffectivity batch (background process, every legal entity)A sales price's To date is after the batch's position and before the run date, and no other sales price of the same agreement is in effect on the day after that To date

Sales-price rows that are inserted or updated outside a journal post - for example through a data entity or by code that calls PriceDiscTable.insert() or update() - are not classified by these events; the record-based Sales price trade agreement changed event (catalog category Accounts receivable) reports them. The journal post itself writes PriceDiscTable with set-based statements; whether those writes also raise the record-based event depends on the Accounts receivable parameters Skip price agreement insert alerts (rows the post inserts) and Skip price agreement update alerts (rows it updates). Set to Yes, a journal post raises only the events in the table above; set to No, the record-based event is also raised for each such row.

Journal posting hook​

  • Extension class: MGCLatticePriceDiscAdmCheckPost_Class_Extension, decorated with [ExtensionOf(classStr(PriceDiscAdmCheckPost))]; the classification is done by MGCLatticeTradeAgreementPriceJournalClassifier.
  • CoC methods:
    • public void initJournalNum(PriceDiscJournalNum _journalNum) - records the number of the trade-agreement journal being posted.
    • protected void createOrUpdatePriceDiscTableRecords() - before next, finds for each inserting sales-price journal line the existing sales price of the same agreement that is in effect on the line's From date (its From date is on or before, and its To date is empty or on or after, the line's From date; the latest-starting one when several are); calls next (the standard post, which updates the rows that journal lines reference and inserts the new rows with set-based statements that skip the table's insert() and update() methods, so a hook on those methods cannot see them); then classifies the posted journal's lines (PriceDiscAdmTrans with that journal number) and sends the events.
  • Firing condition: the journal line has the sales price relation, is not marked for deletion and does not reference an existing row (PriceDiscTableRef is 0); the row the post inserted for it is found exactly, through the journal line it was copied from (PriceDiscTable.OriginalPriceDiscAdmTransRecId), and is a sales price; and no sales price of the same agreement was in effect on the line's From date before the post. When one was, the line raises Sales price agreement superseded instead. An earlier price of the same agreement that ended before the new From date, or starts after it, does not count, so the new price is Created. Two lines of the same journal for the same agreement do not see each other.
  • Coverage: every posting route that goes through PriceDiscAdmCheckPost::runFromContract() - Post on the trade-agreement journal, posting in batch, and journals posted programmatically. Validate-only runs post nothing and raise nothing.
  • Volume cap: at most 1,000 events are sent per posted journal, counting Created, Modified and Superseded together (only the activated ones). Updated rows are reported first, then inserted rows, which is the order the standard post writes them. When the cap is reached the post shows the message "Sales-price trade-agreement event emission was capped at 1000 events for journal journal number; remaining changes were not emitted individually." and the remaining changes raise no event.
  • Transaction and failure handling: the hook runs inside the journal-posting transaction (PriceDiscAdmCheckPost::runFromContract()), so send() only writes to the business events commit log and delivery happens after commit; a post that fails or is rolled back never delivers. Inside that transaction an X++ catch block does not run, so the hook does not rely on one: every lookup is guarded, a line whose data is missing is skipped, and nothing in the classification throws on purpose.
  • Enablement gate: the classification checks BusinessEventsConfigurationReader::isBusinessEventEnabled() for each of Created, Modified and Superseded once per post, so the three are activated independently; when none is active the hook does no work at all.
  • No Lattice parameters or other setup are required.

The CoC wrapper:

protected void createOrUpdatePriceDiscTableRecords()
{
    MGCLatticeTradeAgreementPriceJournalClassifier classifier = MGCLatticeTradeAgreementPriceJournalClassifier::newForPosting(latticeJournalNum);

    classifier.snapshotBeforePost();

    next createOrUpdatePriceDiscTableRecords();

    classifier.emit(classifier.classifyAfterPost());
}

The part of classifyAfterPost() that handles journal lines inserting a new row:

while select RecId from line
    where line.JournalNum        == journalNum
       && line.MustBeDeleted     == NoYes::No
       && line.PriceDiscTableRef == 0
       && line.Relation          == PriceType::PriceSales
    join row
        where row.OriginalPriceDiscAdmTransRecId == line.RecId
           && row.Relation                       == PriceType::PriceSales
{
    if (reported.in(row.RecId))
    {
        continue;
    }

    reported.add(row.RecId);

    if (priorByLineRecId.exists(line.RecId))
    {
        if (includeSuperseded)
        {
            prior = priorByLineRecId.lookup(line.RecId);

            if (!this.addResult(results, MGCLatticeTradeAgreementPriceChangeType::Superseded, row, conPeek(prior, 2), conPeek(prior, 1), conNull()))
            {
                break;
            }
        }
    }
    else if (includeCreated)
    {
        if (!this.addResult(results, MGCLatticeTradeAgreementPriceChangeType::Created, row, 0, 0, conNull()))
        {
            break;
        }
    }
}

Payload Contract​

One row per [DataMember], in declaration order. All six sales price agreement events use this contract; the sources are fields on the posted PriceDiscTable row, mapped in initialize().

JSON fieldDisplay labelType / EDTSourceNotes
legalEntityLegal EntityDataAreaIdPriceDiscTable.DataAreaIdCompany of the trade agreement row
changeTypeChange Typeintenum2int(MGCLatticeTradeAgreementPriceChangeType)Integer change type: Created 0, Modified 1, Superseded 2, Deleted 3, Effective 4, Expired 5. Always 0 for this event
changeTypeNameChange Type Namestrenum2Symbol(enumNum(MGCLatticeTradeAgreementPriceChangeType), …)Change type symbol; always "Created" for this event
priceTypePrice Typeintenum2int(PriceDiscTable.Relation)Integer value of the PriceType enum; always 4 (PriceSales)
priceTypeNamePrice Type Namestrenum2Symbol(enumNum(PriceType), enum2int(PriceDiscTable.Relation))Always "PriceSales"
accountCodeAccount Codeintenum2int(PriceDiscTable.AccountCode)PriceDiscPartyCodeType: 0 = Table (one customer), 1 = GroupId (customer price group), 2 = All (all customers)
accountCodeNameAccount Code Namestrenum2Symbol(enumNum(PriceDiscPartyCodeType), …)Symbol of accountCode: Table, GroupId or All
accountRelationAccount RelationPriceDiscAccountRelationPriceDiscTable.AccountRelationCustomer account or price group; empty when accountCode is 2
itemCodeItem Codeintenum2int(PriceDiscTable.ItemCode)PriceDiscProductCodeType: 0 = Table (one item), 1 = GroupId, 2 = All
itemCodeNameItem Code Namestrenum2Symbol(enumNum(PriceDiscProductCodeType), …)Symbol of itemCode: Table, GroupId or All
itemRelationItem RelationPriceDiscItemRelationPriceDiscTable.ItemRelationItem number (or item group)
currencyCodeCurrency CodeCurrencyCodePriceDiscTable.CurrencyCurrency of the price
unitIdUnitUnitOfMeasureSymbolPriceDiscTable.UnitIdUnit of measure the price applies to
quantityAmountFromQuantity FromAmountQtyPriceDiscTable.QuantityAmountFromFrom quantity of the row's quantity break
quantityAmountToQuantity ToAmountQtyPriceDiscTable.QuantityAmountToTo quantity of the row's quantity break; 0 when the break has no upper limit
inventDimIdInventory DimensionsInventDimIdPriceDiscTable.InventDimIdInventory dimension combination the price applies to; AllBlank when the price is not dimension-specific
priceUnitPrice UnitPriceUnitPriceDiscTable.PriceUnitNumber of units the amount is quoted for
fromDateFrom DateFromDatePriceDiscTable.FromDateStart of the validity period, in the \/Date(milliseconds)\/ form. A row without a start date carries 1900-01-01 (\/Date(-2208988800000)\/)
toDateTo DateToDatePriceDiscTable.ToDateLast valid day, in the same form. An open-ended price carries 1900-01-01 (\/Date(-2208988800000)\/)
amountAmountPriceDiscAmountPriceDiscTable.AmountThe new price
oldAmountOld AmountPriceDiscAmountNot used by this eventAlways 0
discountPercentDiscount PercentDiscPctPriceDiscTable.Percent1Discount percentage stored on the row (Percent1); normally 0 on a sales price row
priceDiscTableRecIdPrice Disc Table RecIdRecIdPriceDiscTable.RecIdRecord ID of the new row
previousPriceDiscTableRecIdPrevious Price Disc Table RecIdRecIdNot used by this eventAlways 0
changedFieldsChanged Fieldslist of strNot used by this eventAlways an empty array

Every Lattice event also carries the Lattice ordering and correlation envelope, inherited from MGCLatticeBusinessEventContractBase: eventSequence (Int64 - increasing across the whole catalog and all companies, allocated when the event is sent inside the business transaction; it orders the events of one record, but two transactions can commit in the opposite order of their values, and gaps are normal and permanent - see the events overview), correlationId (String - always Scope:Key: Event: followed by a GUID unique to this emission, unless the event joins a run) and schemaVersion (Int - the payload shape version; 1 for this contract). D365 F&O also adds its standard envelope fields to every business event payload: BusinessEventId, BusinessEventLegalEntity, ContextRecordSubject, ControlNumber, EventId, EventTime, EventTimeIso8601, InitiatingUserAADObjectId, MajorVersion, MinorVersion, and ParentContextRecordSubjects. Do not rely on the order of members in the delivered JSON.

Example Payload​

{
    "BusinessEventId": "MGCLatticeTradeAgreementPriceCreatedBusinessEvent",
    "ControlNumber": 5637148845,
    "EventId": "9930A2C5-1C3E-418D-BE77-8A1DE8721187",
    "EventTime": "\/Date(1790244866000)\/",
    "EventTimeIso8601": "2026-09-24T10:14:26.9400742Z",
    "MajorVersion": 0,
    "MinorVersion": 0,
    "BusinessEventLegalEntity": "USMF",
    "ContextRecordSubject": "",
    "InitiatingUserAADObjectId": "{36600B98-DFF3-E9DE-A758-E2A9AAAF4F25}",
    "ParentContextRecordSubjects": [],
    "eventSequence": 48198,
    "correlationId": "Event:28f9ce71-f71a-4645-b1b1-38d72bf3a056",
    "schemaVersion": 1,
    "legalEntity": "usmf",
    "changeType": 0,
    "changeTypeName": "Created",
    "priceType": 4,
    "priceTypeName": "PriceSales",
    "accountCode": 0,
    "accountCodeName": "Table",
    "accountRelation": "US-004",
    "itemCode": 0,
    "itemCodeName": "Table",
    "itemRelation": "T0005",
    "currencyCode": "USD",
    "unitId": "ea",
    "quantityAmountFrom": 1,
    "quantityAmountTo": 0,
    "inventDimId": "AllBlank",
    "priceUnit": 1,
    "fromDate": "\/Date(1790812800000)\/",
    "toDate": "\/Date(-2208988800000)\/",
    "amount": 1249.00,
    "oldAmount": 0,
    "discountPercent": 0,
    "priceDiscTableRecId": 22565424071,
    "previousPriceDiscTableRecId": 0,
    "changedFields": []
}

Activation​

In the D365FO client, go to System administration > Setup > Business events > Business events catalog. Find this event by name ("Sales price agreement created") or by filtering the Category column to Sales orders. Select it and use Activate to bind it to a configured endpoint (for example, an Azure Service Bus queue, Event Grid topic, or HTTPS webhook). No other setup is needed: the event fires whenever a trade-agreement journal with qualifying sales-price lines is posted.