Entities
Table of Contents
Classes
- Cart
- Persistent shopping cart stored in the database, the alternative to the default session
storage (chosen per deployment by `%eshop.cart.storage%`, see
{@see \App\UI\Front\Eshop\Models\Mappers\CartMapperFactory}).
- CartItem
- Line of a persistent cart: set id and quantity, without a price.
- CartVoucher
- Discount code applied in a persistent cart: only the code, no validation or value (price
and validity are always verified by checkout, not by the cart).
- CategoryParameterRel
- Link between an eshop category and a parameter (`cms_mod_eshop_category_parameter_rel`),
composite PK (category + parameter); a port of the Bazaar triple
({@see \App\Core\Base\Shared\Bazaar\Models\Entities\CategoryParameterRel}).
- Complaint
- Complaint aggregate. The state is a single FK to {@see ComplaintStatus}, with no separate
enum column.
- ComplaintFileRel
- Complaint attachment: a rel to the shared System `File` (composite PK complaint + file, like
Bazaar `AdvertFileRel`). The path is never built by hand but taken from
`File::getFullPath()`. `removed` is a soft delete (as in `AdvertFileRel`), so multi-upload
deletes one file at a time without losing the order of the remaining ones.
- 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.
- FeedParameter
- Node of the nested-set tree describing the XML structure of a feed: the root item node is
repeated per product set, nodes with `multiple=1` (such as `PARAM`) repeat their children
per source value. The tree has two levels.
- FeedParameterAction
- Value source for a feed node: a small code list (`input`, `getProductId`,
`getProductSetName`, ...); {@see \App\UI\Api\Eshop\Models\Generators\FeedXmlGenerator} holds
the map from `action.key` to callable. Read-mostly with no admin CRUD, so the entity has no
presenter, only Manager/Service/Mapper/Repository for `findAll()` in the parameter edit
select ({@see FeedParameter::$action}).
- FeedParameterActionText
- Translation of a feed action name ({@see FeedParameterAction}); derived identity (PK =
`languageId` + association to the parent), like {@see ShipperTariffText}.
- FeedParameterRel
- Per-product-set override of the value of one feed node: when a row exists for
(parameter, productSet), the generator uses this `value` instead of the value computed by the
node action.
- FeedProductCategoryRel
- Textual mapping of a category to a value per feed (used by the `getCategories` action).
- Gift
- Gift: a free gift added to an order. It has two links to product sets:
- `$productSet`: the gift is itself a sellable product set (nullable; the alternative is a
purely named gift with an `$image`),
- `$offerSets`: many-to-many, the gift is offered when buying the set (edited in the
product set form).
- 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
- Order aggregate: owns items (+ units/fees cascaded through `OrderItem`), 1:1 shipper and payment
method, vouchers, gifts and payments (all cascade persist/remove with orphan removal; save is a
full replace).
- 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
- ParameterGroup
- ParameterGroupText
- ParameterRule
- 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}, not on the method.
- PaymentMethodPrice
- Has a surrogate PK (`payment_method_price_id`): the matrix is an append-only time series with its own
`dateFrom`, see {@see BasePaymentMethodPrice}. Both associations are therefore plain FK columns, not
part of the PK; logical uniqueness (tariff × paymentMethod × currency × dateFrom) is enforced by a
unique index in the database, not by the Doctrine identifier.
- 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 view `cms_mod_eshop_product_set_current_prices`; never written. The
composite PK is informational only (the view has no real PK constraint).
- 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
- Parameter value on a sellable set, analogous to Bazaar `AdvertParameterRel` but with a
surrogate PK (`product_set_parameter_rel_id`) instead of the composite (set, parameter).
- 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
- Daily statistic of a sellable set: an append-only series with one row per day × metric type
(`type`, currently only `'views'`: product detail views from the front `registerEvent`,
upserted by {@see
\App\UI\Api\Eshop\Models\Repositories\Db\ProductSetStatisticRepository::incrementDailyCount()}).
- 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 tariff's payment matrix: an owned collection of {@see PaymentMethodPrice}
keyed by (tariff × paymentMethod × currency).
- 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}).