Entities
Table of Contents
Classes
- CategoryParameterRel
- Admin variant of the e-shop category to parameter link (`cms_mod_eshop_category_parameter_rel`).
- Complaint
- Complaint aggregate. The state is a single FK to {@see ComplaintStatus}, with no separate
enum column.
- ComplaintFileRel
- Admin variant of the complaint to file link (composite PK `complaint` + `file`).
- ComplaintItem
- Complaint line: a snapshot of the complained item (name, code, VAT, price from the original
order at the time the complaint was created, like `OrderItem`). `productSet` and
`orderItem` are references only (`SET NULL`); `orderItem` keeps the link to the original
order line from which {@see \App\UI\Api\Eshop\Models\Managers\ComplaintStockManager} looks
up the cost price of the issue document for the return.
- ComplaintSolution
- Complaint solution: a purely descriptive code list (own solution, new goods, repair of goods,
refund) without behavioral flags. {@see Complaint} references it twice: `solution` (chosen
by the admin) and `preferredSolution` (preferred by the customer).
- ComplaintSolutionText
- ComplaintStatus
- Complaint status: a node of a simple (negated) state graph, a single FK code list with no
separate enum.
- ComplaintStatusText
- Complaint status text: besides the name it carries the e-mail template
(`emailSubject`/`emailBody`) that
{@see \App\UI\Api\Eshop\Models\Generators\ComplaintEmailGenerator} sends to the customer on a
transition into a status with the `sendEmail` flag (like `OrderStatusText`).
- Feed
- XML feed definition (Heureka.cz, Zbozi.cz and similar): root and item tag
(`rootTag`/`itemTag`), language and currency of values, and an item limit.
- FeedParameterAction
- Read-only code list (no admin CRUD, only `findAll()` for the select in the feed parameter
edit form), see {@see BaseFeedParameterAction}.
- FeedParameterActionText
- Translation of a feed action name ({@see FeedParameterAction}); derived identity (PK =
`languageId` + association to the parent), like {@see ShipperTariffText}.
- FeedProductCategoryRel
- Textual mapping of a category to a value per feed (used by the `getCategories` action).
- Gift
- The many-to-many `offerSets` is mapped here too: the picker that selects the product sets
a gift is offered with saves through the object graph.
- GiftPrice
- Cart value thresholds of a gift per currency: the gift is offered when the cart value lies in
the interval [priceFrom, priceTo] (null = unbounded on that side). `price` is the informative
value of the gift and does not enter any calculation.
- GiftText
- Order
- Admin order aggregate (bridge to the Api).
- OrderGift
- Snapshot of a gift on an order: only name and amount; it does not enter `total_price`. The
gift is a reference only (`SET NULL`).
- OrderItem
- Order line: an immutable snapshot of a sellable product set at save time (name, code and unit
from the catalog, prices from `PriceResolver`, rate from the VAT engine (`TaxManager`); built by
`OrderSnapshotBuilder`). `productSet` is a reference only (`SET NULL`), so deleting the set
does not invalidate the snapshot.
- OrderItemFee
- Snapshot of an order item fee (name, unit price and rate at save time; `fee` is a reference
only, `SET NULL`). Fees enter `total_price`: they are already included in
`OrderItem::$price`/`$priceWithVat`, and this row is the breakdown for the admin detail and
for the flat InvoiceItem row ("{fee} - {item}").
- OrderItemUnit
- Frozen breakdown of an order item into Store stock items: a snapshot of
`SetCompositionService::decompose()` at save time (stockItemQuantities x line quantity).
- OrderPayment
- Matched payment of an order (many-to-many join, PK = order + paymentId). The composite PK
protects against a duplicate payment callback: matching the same payment twice is a
duplicate key and a no-op.
- OrderPaymentMethod
- 1:1 snapshot of the order's payment method (PK = order; owned FK in the PK). `price` is the
payment surcharge without VAT plus the rate (binding rule: it is entered without VAT),
`priceWithVat` is computed by `OrderCalculator`. The method is a reference only (`SET NULL`).
- OrderShipper
- 1:1 snapshot of the order's shipping (PK = order; owned FK in the PK). `price` is without VAT
plus the rate (shipping is entered without VAT), `priceWithVat` is computed by
`OrderCalculator`. Shipper and tariff are references only (`SET NULL`), so the snapshot
survives deleting the code list.
- OrderStatus
- Order status: a node of the state graph. Behavioral flags tell `OrderTransitionManager` which
effects a transition into this status triggers (the order of effects is defined there, this
is configuration only).
- OrderStatusText
- Order status text: besides the name it carries the status e-mail template
(`emailSubject`/`emailBody`) that `OrderEmailGenerator` sends to the customer on a transition
into a status with the `sendEmail` flag.
- OrderVoucher
- Snapshot of a voucher applied to an order (table `cms_mod_eshop_order_voucher_rel`).
- Parameter
- Admin variant of the e-shop parameter (`cms_mod_eshop_parameters`), hydrated from `api/eshop/parameter`.
- ParameterGroup
- Admin variant of the parameter group (`cms_mod_eshop_parameter_groups`), hydrated from `api/eshop/parameter-group`.
- ParameterGroupText
- ParameterRule
- Admin variant of the display rule of a parameter or group (`cms_mod_eshop_parameter_rules`).
- ParameterRuleCondition
- ParameterRuleConditionValue
- ParameterRuleSource
- Derived identity: PK = association [rule, parameter] (mapped in the leaf). The scalars
`ruleId` and `parameterId` are read-only mirrors of the same columns, mapped for filters
(`EqualFilter('ruleId'/'parameterId')`); writes belong solely to the associations
(`insertable`/`updatable` false). There is no `setRuleId()`/`setParameterId()`, so they cannot
desync.
- ParameterRuleTarget
- ParameterText
- PaymentMethod
- Has no price collection: the {@see PaymentMethodPrice} matrix hangs on
{@see ShipperTariff::$paymentPrices} and is edited in the tariff form, not the method form.
- PaymentMethodPrice
- Payment method price row with a surrogate PK (`payment_method_price_id`).
- PaymentMethodText
- Producer
- Producer (brand): language-neutral, holds only `name`, no texts.
- Product
- Abstract product card: the common base of 1..n sellable `ProductSet`s (via
`product_sets.cms_mod_eshop_products_product_id`, nullable for bundle sets without a single
owner). Categories stay here as many-to-many.
- ProductCategory
- Product category as a nested set (`lft`/`rgt`/`level` + `parentId`, one tree without scope,
like Blog `Category`). Many-to-many to `Product` is mapped on the owning side {@see
Product::$categories}; there is no back collection here.
- ProductCategoryText
- Category texts: `href` is the per-language slug (routing), `meta_*` feed the page header,
the fulltext index on (name, info) is kept at database level.
- ProductImport
- History and state of one import job: file, format, job settings, state, counts, times and
the uploader. Holds bookkeeping only; parsing, validation and execution live elsewhere.
- ProductSet
- Main sellable entity. `typeId = PRODUCT(1)` is the sales card of exactly one physical
variant (`$variant`, unique column); `typeId = BUNDLE(2)` is a set composed of other sets
(`$setItems`, including finished bundles, recursively; see `SetCompositionService`).
- ProductSetAccessory
- Accessory (set to set, self-reference) with ordering. `productSet` is the owning set
(inversedBy accessories); `accessorySet` is the recommended accessory (no back collection).
- ProductSetCurrentPrice
- Read-only mapping over the database view `cms_mod_eshop_product_set_current_prices`.
- ProductSetFee
- Fee: a named item with its own price time series ({@see ProductSetFeePrice}). Many-to-many
to `ProductSet` is mapped on the owning side {@see ProductSet::$fees}.
- ProductSetFeePrice
- Append-only time series of fee prices. Composite PK (fee, currency, publishedDatetime) with
the owned FK in the PK; `vat` is a value association outside the PK (set null).
- ProductSetFeeText
- ProductSetFeeType
- Fee type list (content-less pivot plus translations).
- ProductSetFeeTypeText
- ProductSetImageRel
- Link between `ProductSet` and an image with ordering (gallery, drag and drop), same as Blog
`GalleryAssetRel` with `ProductSet` in the gallery role. Composite PK (set + image); the
concrete `#[ORM\Id]` and many-to-one come from the Api/Admin leaf. Images are saved by hard
delete + insert (`afterSave()`); there is no soft delete.
- ProductSetLink
- Multilingual link (manual, video…): `name` and `value` are per language (see the text
entity). Many-to-many to `ProductSet` is mapped on the owning side {@see
ProductSet::$links}.
- ProductSetLinkText
- ProductSetLinkType
- Link type list (manual, video…): content-less pivot plus translations. The PK column is
named `type_id` in the database (not `product_set_link_type_id`), taken 1:1 from legacy.
- ProductSetLinkTypeText
- ProductSetParameterRel
- Admin link between a product set and a parameter value.
- ProductSetPrice
- Append-only time series of valid-from prices; future prices are scheduled without a cron
(views `max_published_time_for_prices`/`current_prices`, where `published_time <= now()`).
- ProductSetStatistic
- The admin never writes or reads this entity directly.
- ProductSetText
- Set texts. The fulltext index (name, longName, description, shortDescription) is kept in the
database; this class only maps columns.
- ProductState
- Marketing label of a product ("New", "Clearance"); complements Store stock availability,
does not duplicate it.
- ProductStateText
- ProductTag
- Product tag (badge). `attributeClass` is the CSS class of the badge (appearance only).
- ProductTagText
- ProductText
- ProductType
- Catalog list of product types. Not the same as Invoicer `ProductType` (the PDF matrix axis);
`OrderInvoiceGenerator` maps between them.
- ProductTypeText
- Product type texts, derived identity: PK = languageId + association to the parent.
- ProductVariant
- Thin pivot: the atomic stock unit. `product` is the owning card (cascade); `stockItem` is a
mapping to the Store card (nullable, set null; canonical direction is eshop to Store, like
Invoicer `order_id`). The concrete many-to-one comes from the Api variant, Admin
`#[EntityOf]`.
- SetItemRel
- Set composition item: a parent set (`type_id = 2`) contains another set with a quantity.
- Shipper
- Carrier. Legacy `last_updated_shipper_branch_id` is not carried over (without a branch
import a cache column has no purpose).
- ShipperRegion
- Carrier region: just a grouping of tariffs and branches ("Czech Republic", "Slovakia"…), a
trivial list. It becomes meaningful with a pickup point import; for now it is the minimal FK
target of {@see ShipperTariff}.
- ShipperRegionText
- ShipperTariff
- `$paymentPrices` is the payment matrix of the tariff: an owned collection of
{@see PaymentMethodPrice} keyed by tariff, payment method and currency. It is edited in the
tariff form and saved as a full replace through the object graph (`orphanRemoval`).
- ShipperTariffBranch
- Branch (pickup point for personal collection) belonging to one carrier tariff: one tariff
has many branches.
- ShipperTariffPrice
- Tariff price: an append-only time series per weight interval × currency × validity date
(`dateFrom`). Unlike {@see ProductSetFeePrice}/{@see ProductSetPrice} (composite PK without
surrogate id, where `publishedTime` must be ORM `type: 'string'`), this entity keeps a
surrogate auto-increment `id`, so `dateFrom` is not part of the Doctrine identifier and is a
normal `type: 'datetime'` column. The property is `\DateTime`, not `\DateTimeImmutable`: the
DBAL `datetime` type accepts only `\DateTime` (the immutable one needs
`datetime_immutable`).
- ShipperTariffText
- ShipperText
- Carrier texts, derived identity (PK = languageId + association to the parent).
- Voucher
- Discount coupon. `code` is unique. Either percentage (`hasPercents` + `percents`) or a fixed
amount per currency ({@see VoucherPrice::$price}). Vouchers on an order add up (sum of
percents capped at 100 + sum of fixed amounts; see `OrderCalculator`).
- VoucherPrice
- Voucher parameters per currency: min/max cart value (validation) + fixed discount `price`
(null for a purely percentage voucher). PK = (voucher, currencyId), owned FK in the PK,
`currencyId` is a scalar axis (like {@see ProductSetFeePrice}).