# Conditions and formulas

> The single BOM and single routing of a configurable product — line condition, expression-based selection condition, quantity formula, operation condition and duration formula, configuration precondition; the language, evaluation order, error messages and 25 verified examples.

URL: https://erpdocs.corexlogic.com/en/uretim/kosullar

A configurable product does not get a separate bill of materials and routing for every combination of options. The
product has **one** bill of materials (super BOM) and **one** routing (super routing); rules are written on the lines
and operations. The values the customer selects on the sales order (the configuration) are carried to the production
order, and when the order is released the rules are resolved with these values: which material line is included, in
what quantity, which operation is performed and how many minutes it takes.

This page describes all of the rules. Every example was set up in the demo company and its result was verified with
the BOM's **Yapılandırarak Dene** (Try by Configuring) window or with a real production order.

> **Demo items**
Most examples use fictitious items created in the demo company for this page: **DMO-KSL-01** Ölçülü bantlı konveyör
(made-to-length belt conveyor), **DMO-KSL-02** Yapılandırılabilir dağıtım panosu (configurable distribution panel),
**DMO-KSL-03** Temizlik ürünü partisi (cleaning product batch), **DMO-KSL-04** Ölçüye göre dolap (made-to-measure
cabinet). Ready-made examples with option conditions: **MAM-0003** Ofis çalışma masası (office desk), **MAM-0006**
Paslanmaz depolama tankı (stainless storage tank), **MAM-0001** Motor kontrol panosu (motor control panel).

> **Number format**
In expressions the decimal separator is always a **dot** (`1.05`). The application itself uses the Turkish number
format: values typed into fields (for example **Miktar** `0,6`) and messages quoted from the screen use a decimal
**comma**. In the explanatory text and result tables below, numbers are written in English format (12.24 M);
option names such as **1.000 L** (1,000 L) are quoted exactly as they appear on screen.

## Map of the rules

| Rule | Where it is defined | What it decides | How it is written | Result type |
|---|---|---|---|---|
| Configuration precondition | **Ürün Ana Verileri** (Product Master Data) › item › **Yapılandırma** (Configuration) › the characteristic's **İşlemler** (Actions) › **Koşul** (Condition) | Whether the characteristic **is asked** in sales | Values are ticked (in the import workbook `KABIN = OZEL_OLCU`) | — |
| Constraint (**Sınır koy**, Set a limit) | Same tab › **Nesne Bağımlılıkları** (Object Dependencies) › **Kural Ekle** (Add Rule) | Whether a disallowed combination can be saved | Expression | Yes/No |
| Procedure (**Değer hesapla**, Calculate value) | Same place | What value a characteristic gets | Expression or decision table | The characteristic's type |
| Line condition (option condition) | **Ürün Ağaçları** (Bills of Materials) › revision › the line's **Kuralı Düzenle** (Edit Rule) button › **Satır Kuralı** (Line Rule) | Whether the material line **is included** in the order | Values are ticked on an option characteristic | — |
| Expression-based selection condition | **Satır Kuralı** › **İfadeli koşul** (Expression condition) › **Koşul** (Condition) | Whether the material line is included in the order | Expression | Yes/No |
| Formula quantity | **Satır Kuralı** › **Formüllü miktar** (Formula quantity) (**Özellik × katsayı** (Characteristic × coefficient) or **İfade** (Expression)) | The line's quantity | Coefficient or expression | Number |
| Operation selection condition | **Rotalar** (Routings) › revision › the operation's **Seçim koşulu ve formüller** (Selection condition and formulas) button › **Seçim koşulu** (Selection condition) | Whether the operation is included in the order | Expression | Yes/No |
| Duration formula | Same place › **Hazırlık formülü (dk)** (Setup formula, min) · **Makine formülü (dk)** (Machine formula, min) · **İşçilik formülü (dk)** (Labor formula, min) | The operation's duration | Expression | Number (minutes) |

BOM line and operation rules can be written **only** in the BOM and routing of a **configurable item**. If a condition
is written in the BOM of an item that is not configurable, saving is rejected with this message:
`Seçim koşulu yalnız yapılandırılabilir kartın ürün ağacında kullanılır.` (A selection condition is used only in the
BOM of a configurable item.) — for a quantity formula
`Miktar formülü yalnız yapılandırılabilir kartın ürün ağacında kullanılır.` (A quantity formula is used only in the
BOM of a configurable item.), and in a routing
`Seçim koşulu ve formüllü süre yalnız yapılandırılabilir kartın rotasında kullanılır.` (Selection conditions and
formula durations are used only in the routing of a configurable item.).

## When and in what order rules are evaluated {#sira}

1. **Value entry** — characteristic values are entered on the sales order line (or in the **Yapılandırarak Dene**
   (Try by Configuring) window). A characteristic whose precondition is not met is **not shown**; it cannot be given a
   value and its required setting is not applied. A required characteristic that is asked and left blank prevents the
   line from being saved.
2. **Object dependencies** are applied in the order of the list: procedures write the calculated value, constraints
   check the combination. A constraint is checked only when its result is **known**.
3. **When the production order is released** (**Yayınla**, Release), the BOM is resolved. Material requirements and
   operations are written to the order at this point; before release the order has no material lines. Lines are
   processed in line-number order, and on each line:
   1. **Option condition** — for each condition characteristic, the entered value must be one of the ticked values.
   2. **Expression-based selection condition** — the result must be **Yes**. If it is **No** or **unknown**, the line
      is not included.
   3. **Quantity** — fixed, `Miktar + katsayı × değer` (quantity + coefficient × value) or `Miktar + ifadenin sonucu`
      (quantity + result of the expression).
4. The same item must not appear twice among the selected lines; if no line is selected, the order is not opened.
5. **The routing is resolved** — for each operation the selection condition (included if Yes), then the setup,
   machine and labor formulas. A duration without a formula is the fixed value in the routing.
6. **Scaling to the order quantity** — `satır miktarı × emir miktarı ÷ ağacın temel miktarı` (line quantity × order
   quantity ÷ base quantity of the BOM), increased by the assembly and component scrap if any. If the quantity came
   from a formula or there is scrap, the result is rounded **up** to the decimal precision of the component's unit
   (ADET (piece) 0, KG/M/M2 3 decimals).

> **Difference between Try by Configuring and the order**
**Yapılandırarak Dene** (Try by Configuring) and the order use **the same** resolver. The window shows values per base
quantity and **without rounding**; the order adds scrap and unit rounding. Example: a sheet-metal line shown as
`60,288 KG` in the window becomes `63,303 KG` on the order with 5% component scrap (60.288 × 1.05 = 63.3024 → rounded
up to 63.303).

## Expression language {#ifade-dili}

Constraints, procedures, expression-based selection conditions, quantity formulas, operation conditions and duration
formulas use **the same language**. Rules are evaluated on the server; the **Sına** (Test) button on the screen performs
the same check without saving.

### Values and notation

| What | How it is written | Example |
|---|---|---|
| Number | Decimal separator is a **dot** | `1.05`, `2.5`, `12` |
| Text, option code | **Single quotes**; a quote inside the text is doubled | `'PVC'`, `'OZEL_OLCU'`, `'Ali''nin'` |
| Yes/No | `EVET` / `HAYIR` (or `TRUE` / `FALSE`) | `KORUMA = EVET` |
| Characteristic | The characteristic's **code**; letters, digits and underscore | `BOY`, `CIKIS_SAYISI` |
| Code with special characters | Square brackets | `[EN-1]`, `[BOY] * 2` |

Codes and keywords are not case-sensitive (`bant_genisligi = '800'` also works). Text comparison also ignores case
and leading/trailing spaces: `BANT_TIPI = 'pvc'` and `BANT_TIPI = ' PVC '` both return Yes.

### Value in the expression by characteristic type

| Characteristic type | What the expression reads | Correct | Wrong |
|---|---|---|---|
| **Seçim** (Selection) | The option's **code** (text) | `BANT_GENISLIGI = '800'` | `BANT_GENISLIGI = 800` (number) · `BANT_GENISLIGI = '800 mm'` (the option's name) |
| **Tam Sayı** (Integer), **Ondalık** (Decimal) | Number | `CIKIS_SAYISI > 12`, `BOY * 2` | `BOY > '10'` |
| **Evet/Hayır** (Yes/No) | Yes/No | `KORUMA = EVET` | `KORUMA = 'EVET'`, `KORUMA = 1` |
| **Tarih** (Date) | Text `'yyyy-MM-dd'` | `TESLIM >= '2027-01-01'` | — |
| **Metin** (Text) | Text (empty text counts as not entered) | `DOLU(ACIKLAMA)` | `ACIKLAMA <> ''` (unknown if empty) |

The option's **name** (shown on screen, e.g. "800 mm") is not used in expressions; comparison is made **by code**. In
the rule window, the **Özellikler** (Characteristics) and **… değerleri** (… values) buttons insert the item's
characteristic and option codes at the cursor position.

### Operators and precedence

Precedence from lowest to highest: `VEYA` → `VE` → `DEĞİL` → comparison → `+ -` → `* /` → unary `-`. Parentheses
always come first.

| Operator | Meaning | Equivalent notation | Example → result |
|---|---|---|---|
| `+ - * /` | Arithmetic | — | `2 + 3 * 4` → 14 · `10 / 4` → 2.5 |
| `+` on text | Concatenation | — | `BANT_TIPI + '-' + BANT_GENISLIGI` → PVC-600 |
| `=` `<>` | Equal · not equal | `!=` = `<>` | `BOY != 6` (BOY 6) → No |
| `<` `<=` `>` `>=` | Comparison | — | `BOY = 6.0` (BOY 6) → Yes |
| `IN ( … )` | One of the listed values | `İÇİNDE` | `BOY IN (6, 12)` (BOY 12) → Yes |
| `VE` | Both (AND) | `AND` | |
| `VEYA` | Either is enough (OR) | `OR` | |
| `DEĞİL` | Negation (NOT) | `DEGIL`, `NOT` | `DEĞİL BOY > 10 VE BOY > 5` (BOY 8) → Yes |

- Comparisons cannot be chained: `BOY > 10 > 2` cannot be written (`Beklenmeyen '>' (konum 10).` — Unexpected '>'
  (position 10).). Join two conditions with `VE`.
- `DEĞİL` negates only the comparison immediately to its right: `DEĞİL A VE B` = `(DEĞİL A) VE B`. To negate several
  conditions, use parentheses: `DEĞİL (A VEYA B)`.
- Both sides of a comparison must be of the same type; Yes/No is compared only with `=` and `<>`.
- Arithmetic works only with numbers: `KORUMA + 1` → `'+' yalnız sayılarla kullanılır.` ('+' is used only with
  numbers.)

### Functions

| Function | Equivalent | What it does | Example → result |
|---|---|---|---|
| `EGER(koşul, a, b)` | `EĞER`, `IF` | If the condition (`koşul`) is Yes, `a`; if No, `b`; if unknown, unknown. **Only the selected branch** is evaluated | `EGER(BOY > 10, 2, 1)` (BOY 12) → 2 |
| `YUVARLA(x[, n])` | `ROUND` | Rounds to n decimals (n 0–10, blank = 0); half rounds up | `YUVARLA(2.345, 2)` → 2.35 · `YUVARLA(2.5)` → 3 |
| `YUKARIYUVARLA(x, adım)` | `ROUNDUP` | Rounds up to the next multiple of the step (`adım`, step > 0) | `YUKARIYUVARLA(2.37, 0.5)` → 2.5 |
| `TAVAN(x)` | `CEIL` | Next integer up | `TAVAN(2.1)` → 3 · `TAVAN(-2.5)` → -2 |
| `TABAN(x)` | `FLOOR` | Next integer down | `TABAN(2.9)` → 2 · `TABAN(-2.5)` → -3 |
| `MIN(a, b, …)` | — | The smallest (one or more values) | `MIN(3, BOY, 8)` (BOY 5) → 3 |
| `MAX(a, b, …)` | — | The largest | `MAX(0.6, CIKIS_SAYISI * 0.05)` (20) → 1 |
| `MUTLAK(x)` | `ABS` | Absolute value | `MUTLAK(2 - BOY)` (BOY 5) → 3 |
| `DOLU(özellik)` | `SPECIFIED` | Yes if the characteristic (`özellik`) has been entered, No if not — **never returns unknown** | `DOLU(KORUMA)` |
| `TABLO('KOD')` | `TABLE` | Whether the values match a row of the variant table | Only in constraints and procedures |
| `TABLODEGER('KOD', 'SÜTUN')` | `LOOKUP`, `TABLODEĞER` | The column (`SÜTUN`) value of the matching row | Only in constraints and procedures |

The selection condition and quantity formula of a BOM line do not query variant tables:
`Seçim koşulu varyant tablosu sorgulamaz.` (A selection condition does not query a variant table.) ·
`Miktar formülü varyant tablosu sorgulamaz.` (A quantity formula does not query a variant table.)
If you need a value from a table, write it to a characteristic calculated by a **procedure** and read that
characteristic on the line ([Example 8](#ornek-8)). An expression can be at most **1000** characters long.

### Unknown value — three-valued logic {#bilinmeyen-deger}

A characteristic that has not been entered (or was not asked because its precondition was not met) is **unknown**.
Arithmetic and comparisons involving an unknown value also return unknown. A result can therefore be Yes, No or
**unknown**.

| Expression | Values | Result |
|---|---|---|
| `KORUMA = EVET` | KORUMA not entered | unknown → the line is **not included** |
| `KORUMA <> EVET` | KORUMA not entered | unknown → the line is **not included** (not No!) |
| `BOY * 2` | BOY not entered | unknown → the quantity formula **prevents the order from opening** |
| `BOY > 10 VEYA KORUMA = EVET` | BOY 12, KORUMA not entered | Yes (`EVET VEYA ?` = Yes) |
| `BOY > 10 VE KORUMA = EVET` | BOY 8, KORUMA not entered | No (`HAYIR VE ?` = No) |
| `DEĞİL DOLU(KORUMA) VEYA KORUMA = HAYIR` | KORUMA not entered | Yes |
| `DEĞİL DOLU(KORUMA) VEYA KORUMA = HAYIR` | KORUMA Yes | No |
| `EGER(KORUMA = EVET, BOY * 2.4, 0)` | BOY 10, KORUMA not entered | unknown → the order is not opened |

The effect of an unknown value depends on the rule:

| Rule | If the result is unknown |
|---|---|
| Expression-based selection condition, operation selection condition | The line / operation is **not included** (as with No) |
| Quantity formula | Error: `N. satırın miktar formülü bilinmiyor — okuduğu değerlerden biri konfigürasyonda yok (…)` (The quantity formula of line N is unknown — one of the values it reads is not in the configuration (…)) |
| Duration formula | Error: `N numaralı operasyonun işçilik formülü hesaplanamadı — konfigürasyonda gereken değer yok.` (The labor formula of operation N could not be calculated — a required value is missing from the configuration.) |
| Constraint | **Not checked** (passes) |

For this reason, write a rule that reads an optional (not required) characteristic with the question "what should
happen if it is not entered?" in mind; use `DOLU(…)` if necessary.

### Syntax and evaluation messages {#iletiler}

The **Sına** (Test) button and saving check the syntax and the codes. Value-dependent errors (division by zero, a
result of the wrong type, a missing value) appear only with values — in **Yapılandırarak Dene** (Try by Configuring)
or when the order is released.

| Notation | Message | English meaning | When |
|---|---|---|---|
| `BOY >= 10 VE` | `İfade eksik bitti.` | The expression ended incomplete. | Test / save |
| `(BOY + 2` | `')' bekleniyordu, ifade bitti.` | ')' was expected, the expression ended. | Test / save |
| `'PVC` | `Kapanmamış metin (konum 1).` | Unclosed text (position 1). | Test / save |
| `BANT_GENISLIGI = "800"` | `Beklenmeyen karakter '"' (konum 18).` | Unexpected character '"' (position 18). | Test / save |
| `BOY * 1,05` | `Beklenmeyen ',' (konum 8).` | Unexpected ',' (position 8). | Test / save |
| `BOY % 2` | `Beklenmeyen karakter '%' (konum 5).` | Unexpected character '%' (position 5). | Test / save |
| `KAREKOK(BOY)` | `Bilinmeyen fonksiyon 'KAREKOK' (konum 1).` | Unknown function 'KAREKOK' (position 1). | Test / save |
| `UZUNLUK > 10` (not on the item) | `Seçim koşulundaki 'UZUNLUK' 'DMO-KSL-01' kartının özelliği değil.` | 'UZUNLUK' in the selection condition is not a characteristic of item 'DMO-KSL-01'. | Test / save |
| `TABLO('X')` on a line | `Seçim koşulu varyant tablosu sorgulamaz.` | A selection condition does not query a variant table. | Test / save |
| `BOY / 0` | `Sıfıra bölme.` | Division by zero. | With values |
| `EGER(BOY > 10, 2)` | `EGER(koşul, a, b) üç değer alır.` | EGER(condition, a, b) takes three values. | With values — Test reports it as valid |
| `EGER(BOY, 1, 2)` | `EGER'in koşulu Evet/Hayır olmalı.` | The condition of EGER must be Yes/No. | With values |
| `BANT_GENISLIGI = 800` | `'=' iki yanında aynı türde değer ister.` | '=' requires values of the same type on both sides. | With values |
| `KORUMA = 'EVET'` | `'=' iki yanında aynı türde değer ister.` | '=' requires values of the same type on both sides. | With values |
| `YUKARIYUVARLA(BOY, 0)` | `YUKARIYUVARLA'nın adımı sıfırdan büyük olmalı.` | The step of YUKARIYUVARLA must be greater than zero. | With values |
| `YUVARLA(BOY, 11)` | `YUVARLA'nın ondalık sayısı 0–10 arası tam sayı olmalı.` | The number of decimals of YUVARLA must be an integer between 0 and 10. | With values |
| `DOLU(BOY * 2)` | `DOLU(özellik) tek özellik kodu alır.` | DOLU(characteristic) takes a single characteristic code. | With values |
| `MAX()` | `MAX için değer sayısı yanlış.` | Wrong number of values for MAX. | With values |
| `BOY * 2` in a selection condition | `N. satırın seçim koşulu Evet/Hayır vermeli.` | The selection condition of line N must return Yes/No. | With values — Test reports it as valid |
| Unknown code in the constraint / procedure form | `ifadedeki 'UZUNLUK' bu kartın özelliği değil.` | 'UZUNLUK' in the expression is not a characteristic of this item. | Test / save |

The position number tells you which character of the expression is meant (counting from 1). An error that appears with
values is reported on the order with the line number: `9. satırın miktar formülü: Sıfıra bölme.` (Quantity formula of
line 9: Division by zero.)

## Line condition (option condition) {#satir-kosulu}

In the upper part of the **Satır Kuralı** (Line Rule) window, every **Seçim** (Selection) characteristic of the item is
listed with its values.

- If no value is ticked for a characteristic, that characteristic is **not** a condition.
- For the same characteristic, **one** of the ticked values is enough (OR): Tank Hacmi (Tank Volume) **1.000 L** or
  **2.000 L**.
- Conditions on different characteristics are required **together** (AND): Renk (Color) **Beyaz** (White) and Masa
  Genişliği (Desk Width) **140 cm**.
- If the characteristic has not been entered, the line is not included; Try by Configuring states the reason:
  `Gelmez — Tank Hacmi girilmedi (koşul: 1.000 L).` (Not included — Tank Volume not entered (condition: 1,000 L).)
- A line can carry conditions on at most 10 characteristics; a characteristic can appear only once on a line.

**The same item on two lines.** An item normally appears on a single line in a revision. Exception: if the option
conditions of two lines **exclude each other** (the ticked values on a shared characteristic do not overlap), the same
item can be on two lines — in MAM-0006, **HAM-0031** 3 mm sheet is on one line with `Tank Hacmi: 2.000 L` at 290 kg and
on the other with `Tank Hacmi: 5.000 L` at 560 kg. Expression-based conditions are **not** taken into account here: the
same item cannot be placed on two lines with the conditions `BOY <= 10` and `BOY > 10`
(`Aynı stok kartı bir revizyonda yalnız bir malzeme satırında yer alabilir.` — The same stock item can appear on only
one material line in a revision.). In such a case, use a single line and write the quantity with `EGER`
([Example 4](#ornek-4)).

**Yes/No characteristics** appear in the window with the **Fark etmez / Evet / Hayır** (Doesn't matter / Yes / No)
buttons; in an expression-based condition the choice is written as `UZAKTAN_IZLEME = EVET`.

## Expression-based selection condition {#secim-kosulu}

The **Satır Kuralı › İfadeli koşul › Koşul** (Line Rule › Expression condition › Condition) field. Any selection that
needs a numeric limit, several characteristics, `VEYA` or `DEĞİL` is written here.

- If the result is **Yes**, the line is included; if it is **No** or **unknown**, it is not.
- It is required **together** (AND) with the ticked option conditions.
- Blank = no expression condition.

## Formula quantity {#miktar-formulu}

**Satır Kuralı › Formüllü miktar** (Line Rule › Formula quantity) has one of three modes:

| Mode | Quantity | Rule |
|---|---|---|
| **Sabit miktar** (Fixed quantity) | The line's **Miktar** (Quantity) field | The quantity must be greater than zero |
| **Özellik × katsayı** (Characteristic × coefficient) | `Miktar + katsayı × özelliğin değeri` (quantity + coefficient × the characteristic's value) | The characteristic is numeric (Tam Sayı/Ondalık, Integer/Decimal); the coefficient is greater than zero |
| **İfade** (Expression) | `Miktar + ifadenin sonucu` (quantity + result of the expression) | The result must be a number |

> **The Quantity field is ADDED to the formula**
On a formula line the **Miktar** (Quantity) field is the "fixed part" and can be zero. On a line with the formula
`2 * BOY` and Miktar `0,6`, the quantity for BOY 6 m is `2 × 6 + 0,6 = 12,6` (2 × 6 + 0.6 = 12.6). If you want the
quantity to come only from the formula, enter `0` in **Miktar**; if you leave 1, every order gets 1 extra unit.

- The calculated quantity (fixed + formula) must be greater than zero:
  `N. satırın konfigürasyona göre hesaplanan miktarı sıfırdan büyük değil.` (The quantity of line N calculated from
  the configuration is not greater than zero.)
- The formula also applies to alternative items: the alternative's own quantity + the result of the same formula.
- Component scrap and assembly scrap are applied to the formula result; on the order the value is rounded up to the
  decimals of the unit.
- In **İfade** (Expression) mode, **Sına** (Test) checks the syntax and the codes; it does not check that the result is
  a number.

## Configuration precondition {#on-kosul}

Makes a characteristic **be asked** only when another characteristic has a certain value: "When Kabin (Cabin)
**Özel Ölçü** (Custom Size) is selected, ask **Kabin Eni** (Cabin Width) and **Kabin Boyu** (Cabin Length)."

- The condition characteristic must be a **Seçim** (Selection) or **Evet/Hayır** (Yes/No) characteristic of the same
  item; a numeric characteristic cannot be a condition.
- For the same characteristic, one of the ticked values is enough (OR); different characteristics apply together (AND).
- A characteristic that is not asked stays **blank** and its required setting is not applied; if it is given a value,
  the line is rejected: `'Kabin Eni' yalnız Kabin: Özel Ölçü (En x Boy) olduğunda girilir.` ('Kabin Eni' is entered
  only when Kabin is Özel Ölçü (En x Boy).)
- If an asked, required characteristic is blank: `'Kabin Eni' özelliğinin değeri girilmemiş.` (No value has been
  entered for the characteristic 'Kabin Eni'.)
- A characteristic cannot be a condition for itself (`Özellik kendisine koşul olamaz.` — A characteristic cannot be a
  condition for itself.); a loop cannot be created
  (`Bu koşul döngü kurar: koşul özelliği dolaylı olarak bu özelliğe bağlı.` — This condition creates a loop: the
  condition characteristic depends indirectly on this characteristic.).
- A condition that would invalidate an existing variant is not saved: `'…' varyantı bu koşulla geçersiz kalır: …`
  (Variant '…' becomes invalid with this condition: …)
- A chain can be built (A → B → C): if the condition characteristic is hidden, the characteristic that depends on it is
  hidden too.

**Precondition and BOM rule together:** a characteristic whose precondition is not met is **unknown** in rules.
Protect a formula that reads this characteristic with `EGER` ([Example 12](#ornek-12)), or tie the line to the same
option condition as the precondition ([Example 9](#ornek-9)).

In the import workbook (Ürün Aktarımı (Product Import) › **Yapılandırma** (Configuration) sheet), the precondition is
written in the **OnKosul** column:

| Notation | Meaning |
|---|---|
| `KABIN = OZEL_OLCU` | Asked if Kabin is Özel Ölçü |
| `PERON_SAYISI = 3 / 4` | If 3 **or** 4 (values of the same characteristic separated by `/`) |
| `KABIN = OZEL_OLCU; DIREK = Evet` | If Kabin is Özel Ölçü **and** Direk is Yes (different characteristics separated by `;`) |
| empty cell | The condition is removed (if the column exists); if the column does not exist, the existing condition is kept |

Values are written with the option **code**; a Yes/No characteristic is written with `Evet` / `Hayır`. Unreadable
cell: `'…' okunamadı — biçim "ÖZELLİK = DEĞER" olmalı.` ('…' could not be read — the format must be
"CHARACTERISTIC = VALUE".) · unknown characteristic: `Koşul özelliği '…' bulunamadı.` (Condition characteristic '…'
not found.) · unknown value: `'…' değerlerinde '…' yok.` ('…' is not among the values of '…'.) · numeric
characteristic: `'…' koşul olamaz — yalnız seçim ve Evet/Hayır özellikleri koşul olur.` ('…' cannot be a condition —
only selection and Yes/No characteristics can be conditions.)

## Super routing: operation condition and duration formula {#super-rota}

In a routing revision, the **Seçim koşulu ve formüller** (Selection condition and formulas) button of each operation
opens four fields under the row: **Seçim koşulu** (Selection condition), **Hazırlık formülü (dk)** (Setup formula,
min), **Makine formülü (dk)** (Machine formula, min), **İşçilik formülü (dk)** (Labor formula, min).

- If the **Seçim koşulu** is Yes, the operation is included in the order; if it is No or unknown, it is not. Blank =
  always.
- If a formula is filled in, the duration is calculated from the formula and **replaces** the fixed value (it is not
  added, unlike the BOM quantity). Blank = the fixed duration in the routing.
- The formula result must be between 0 and 1,000,000 minutes; it is rounded to two decimals.
- If no operation is selected: `Konfigürasyon rotanın hiçbir operasyonunu seçmiyor — rotanın seçim koşullarını düzeltin.`
  (The configuration does not select any operation of the routing — correct the routing's selection conditions.)
- Machine and labor durations are **per base quantity**; setup is **per lot**.

## Object dependencies: constraint and procedure {#nesne-bagimliliklari}

Use **Kural Ekle** (Add Rule) in the **Nesne Bağımlılıkları** (Object Dependencies) section of the item's
**Yapılandırma** (Configuration) tab:

- **Sınır koy (Kısıt)** (Set a limit — Constraint) — the expression must return **Yes**. If it returns No, the sales
  line is not saved and the rule's message is shown (if the message is blank:
  `Konfigürasyon kısıtı sağlanmıyor: <ifade>` — The configuration constraint is not met: expression). A rule of the
  form "if A, then B must hold" is written as `DEĞİL A VEYA B`: `BANT_TIPI <> 'PU' VEYA BOY <= 20`.
- **Değer hesapla (Prosedür)** (Calculate value — Procedure) — the result of the expression (or decision table) is
  written to a characteristic. If the write mode is **Her zaman hesapla** (Always calculate), the user cannot enter a
  different value (`'Ayak Çifti Sayısı' değeri kuraldan hesaplanır (8); farklı değer verilemez.` — The value of 'Ayak
  Çifti Sayısı' is calculated from the rule (8); a different value cannot be entered.); if it is **Girilmezse hesapla**
  (Calculate if not entered), the value is written only while the characteristic is blank, and the user's value is
  kept. A procedure that writes a fraction to an integer characteristic is rejected — use `YUVARLA`.
- **Tablodan seç (Tablo kısıtı)** (Select from table — Table constraint) — the combination of values must match a row
  of a variant table.

A calculated characteristic is read on BOM lines and in the routing **like any other characteristic**. If the same
calculation is needed on several lines, do it once in a procedure and read the result on the lines.

## Writing rules in the import workbook

Instead of entering rules one by one on screen, you can also load them with an import workbook:

| Workbook › sheet | Column | Content |
|---|---|---|
| **Ürün Aktarımı** (Product Import) workbook › **Yapılandırma** (Configuration) | `OnKosul` | Precondition (`KABIN = OZEL_OLCU`) |
| Veri Aktarımı (Data Import) › **Ürün Ağaçları** (Bills of Materials) workbook › **Ağaç Satırları** (BOM Lines) | `SecimKosulu` | Expression-based selection condition (`BOY > 10`) |
| Same sheet | `MiktarFormulu` | Expression quantity; quantity = `Miktar` + result of the formula |
| Same workbook › **Satır Koşulları** (Line Conditions) | `SatirNo`, `OzellikKodu`, `DegerKodu` | Option condition — one row per value |
| Veri Aktarımı (Data Import) › **Rotalar** (Routings) workbook › **Operasyonlar** (Operations) | `SecimKosulu`, `HazirlikFormulu`, `MakineFormulu`, `IscilikFormulu` | Super routing |

## Examples

Each example gives the requirement, the characteristics, the rule, the values entered and the result, and a common
mistake. The "Result" column shows what the **Yapılandırarak Dene** (Try by Configuring) window displays per base
quantity (1 ADET (piece)).

![Try with Configuration — line results and quantity calculation](https://erpdocs.corexlogic.com/en/en/img/screens/uretim/kosul-simulasyon.png)
1. Characteristic values — entered as on the sales line
2. Characteristic computed by a procedure
3. How many lines come, how many do not
4. Calculation of a formula quantity
5. Why the line does not come
6. Expression condition Yes — line comes

### Example 1 — Profile by length (conveyor) {#ornek-1}

**Requirement:** The two side profiles of the conveyor are as long as the conveyor, with a 2% cutting allowance.
**Characteristic:** `BOY` (length; Ondalık (Decimal), m, 2–30, step 0.5). **Line:** HAM-0035 Alüminyum konveyör profili
(aluminum conveyor profile), unit M, **Miktar** (Quantity) `0`. **Formula (İfade, Expression):** `2 * BOY * 1.02`

| BOY | Result |
|---|---|
| 6 | 12.24 M |
| 12.5 | 25.5 M |

**Common mistake:** Leaving the Miktar field at `1` — the result becomes 13.24 M.

### Example 2 — Option condition and formula together (belt) {#ornek-2}

**Requirement:** PVC or PU belt; belt length `2 × BOY` + 0.6 m allowance.
**Lines:** HAM-0056 PVC belt — option condition **Bant Tipi: PVC Endüstriyel** (Belt Type: PVC Industrial); HAM-0057
PU belt — **Bant Tipi: PU Gıdaya Uygun** (Belt Type: PU Food Grade). Both have **Miktar** `0,6` and the formula
`2 * BOY`.

| BOY | Bant Tipi (Belt Type) | HAM-0056 | HAM-0057 |
|---|---|---|---|
| 6 | PVC | 12.6 M | Not included |
| 12.5 | PU | Not included | 25.6 M |

Try by Configuring also shows how the quantity was calculated: `2 * BOY + 0,6 = 12,6`.

### Example 3 — Count by step (carrier roller) {#ornek-3}

**Requirement:** One roller every 0.5 m, plus one extra at the end.
**Line:** HAM-0058 Taşıyıcı makara (carrier roller), ADET (piece), **Miktar** `1`, formula `TAVAN(BOY / 0.5)`.

| BOY | Result |
|---|---|
| 6 | 13 ADET |
| 10 | 21 ADET |
| 12.5 | 26 ADET |

**Common mistake:** Writing `BOY / 0.5 + 1` — if the length is not a multiple of 0.5, a fractional count results; on
the order ADET is rounded up, but the intent becomes unclear. When counting pieces, write `TAVAN` / `TABAN` explicitly.

### Example 4 — Two options with a numeric limit (motor) {#ornek-4}

**Requirement:** 0.75 kW motor up to 10 m, 1.5 kW motor above.
**Lines:** HAM-0054 Motor redüktör 0,75 kW (gear motor 0.75 kW) — expression condition `BOY <= 10`; HAM-0055 Motor
redüktör 1,5 kW (gear motor 1.5 kW) — `BOY > 10`.

| BOY | HAM-0054 | HAM-0055 |
|---|---|---|
| 10 | 1 ADET (`koşul Evet: BOY <= 10` — condition Yes) | Not included (`koşul Hayır: BOY > 10` — condition No) |
| 12.5 | Not included | 1 ADET |

**Common mistake:** Writing the limit on the two lines so that they overlap or leave a gap (`BOY < 10` and `BOY > 10` —
at 10 m no motor is included). Make one side `<=` and the other `>`. The same **item** cannot be used on two lines; if
the item is the same and only the quantity changes, write `EGER(BOY > 10, 2, 1)` on a single line.

### Example 5 — Optional Yes/No (protective cover) {#ornek-5}

**Requirement:** If a protective cover is requested, 2.4 kg of stainless sheet per meter.
**Characteristic:** `KORUMA` (protection; Evet/Hayır (Yes/No), optional). **Line:** HAM-0030 Paslanmaz sac (stainless
sheet), KG, **Miktar** `0`, expression condition `KORUMA = EVET`, formula `BOY * 2.4`.

| BOY | KORUMA | Result |
|---|---|---|
| 12.5 | Yes | 30 KG |
| 10 | No | Not included — `koşul Hayır: KORUMA = EVET` (condition No) |
| 6 | not entered | Not included — `koşulun okuduğu değer girilmedi: KORUMA = EVET` (the value read by the condition was not entered) |

**Common mistake 1:** Writing `KORUMA <> EVET` for the "without cover" case — if it has not been entered, the result is
**unknown** and the line is not included. Correct: `DEĞİL DOLU(KORUMA) VEYA KORUMA = HAYIR`.
**Common mistake 2:** Embedding the condition in the formula: `EGER(KORUMA = EVET, BOY * 2.4, 0)` — if KORUMA is not
entered the formula is unknown and the order is not opened; in addition, when the result is 0 the error
`hesaplanan miktarı sıfırdan büyük değil` (calculated quantity is not greater than zero) appears. Write whether the
line is included with a **condition** and the quantity with a **formula**.

### Example 6 — Option and number together (middle support) {#ornek-6}

**Requirement:** For an 800 mm belt on a conveyor longer than 12 m, 0.8 m of middle support profile every 3 m.
**Line:** HAM-0032 Profil kutu 40x40 (box profile 40x40), M, **Miktar** `0`, expression condition
`BANT_GENISLIGI = '800' VE BOY > 12`, formula `TAVAN(BOY / 3) * 0.8`.

| Bant Genişliği (Belt Width) | BOY | Result |
|---|---|---|
| 800 mm | 12.5 | 4 M |
| 800 mm | 12 | Not included — `koşul Hayır` (condition No) |
| 600 mm | 12.5 | Not included |

**Common mistake:** `BANT_GENISLIGI = 800` (without quotes) — an option code is text:
`'=' iki yanında aynı türde değer ister.` ('=' requires values of the same type on both sides.) This error does not
appear in Test but with values.

### Example 7 — Coefficient from a list (connecting bolt) {#ornek-7}

**Requirement:** For 600 and 800 mm, 8 bolts per 1.5 m; for 400 mm, 4. Bolts are issued by backflush.
**Line:** HAM-0064 Cıvata M8x20 (bolt M8x20), ADET, **Miktar** `0`, **Geri sarf** (Backflush) ticked, formula
`EGER(BANT_GENISLIGI IN ('600', '800'), 8, 4) * TAVAN(BOY / 1.5)`.

| Bant Genişliği (Belt Width) | BOY | Result |
|---|---|---|
| 600 mm | 6 | 32 ADET |
| 400 mm | 10 | 28 ADET |
| 800 mm | 12 | 64 ADET |
| 800 mm | 12.5 | 72 ADET |

### Example 8 — Calculated characteristic (pairs of feet) {#ornek-8}

**Requirement:** The number of pairs of feet is used in several places (BOM lines, routing); the calculation should be
in one place.
**Setup:** Add the characteristic `AYAK_CIFTI` (pairs of feet; Tam Sayı (Integer), optional) to the item; **Nesne
Bağımlılıkları** (Object Dependencies) › **Kural Ekle** (Add Rule) › **Değer hesapla** (Calculate value), target **Ayak
Çifti Sayısı** (Number of Pairs of Feet), **Formül (gelişmiş)** (Formula, advanced), write mode **Her zaman hesapla**
(Always calculate), expression `TAVAN(BOY / 1.5) + 1`.
**Line:** HAM-0049 Ayar ayağı (leveling foot), ADET, **Miktar** `0`, formula `2 * AYAK_CIFTI`.

| BOY | AYAK_CIFTI (calculated) | HAM-0049 |
|---|---|---|
| 10 | 8 | 16 ADET (`2 * AYAK_CIFTI = 16`) |
| 12.5 | 10 | 20 ADET |

The calculated value also appears in the order's configuration text (`Ayak Çifti Sayısı: 10`).
**Common mistake:** Entering a value manually for the calculated characteristic in sales:
`'Ayak Çifti Sayısı' değeri kuraldan hesaplanır (8); farklı değer verilemez.` (The value of 'Ayak Çifti Sayısı' is
calculated from the rule (8); a different value cannot be entered.)

### Example 9 — Dimension with a precondition and a line selected by option (panel cabinet) {#ornek-9}

**Requirement:** The standard cabinet is a semi-finished product from stock; for a custom size, cabinet sheet = width ×
length × 2 faces × 15.7 kg/m².
**Characteristics:** `KABIN` (cabinet; Seçim (Selection): **Standart (800x600)** `STD`, **Özel Ölçü (En x Boy)**
(Custom Size, Width x Length) `OZEL_OLCU`); `KABIN_EN`, `KABIN_BOY` (cabinet width, length; Ondalık (Decimal), m,
required, precondition `KABIN = OZEL_OLCU`).
**Lines:** YM-0001 Pano kabini (panel cabinet) — option condition **Kabin: Standart (800x600)**; HAM-0029 DKP sac 2 mm
(DKP sheet 2 mm), KG, **Bileşen firesi** (Component scrap) 5% — option condition **Kabin: Özel Ölçü (En x Boy)**,
**Miktar** `0`, formula `KABIN_EN * KABIN_BOY * 2 * 15.7`.

| Kabin | Width × Length | YM-0001 | HAM-0029 (Try) | HAM-0029 (on the order) |
|---|---|---|---|---|
| Standart | not asked | 1 ADET | Not included | — |
| Özel Ölçü | 1.2 × 1.6 | Not included | 60.288 KG | 63.303 KG (5% scrap, rounded up) |
| Özel Ölçü | not entered | Not included | Error | The sales line is not saved |

In the last row the window shows two warnings:
`Satış satırı bu değerlerle kaydedilemez: 'Kabin Eni' özelliğinin değeri girilmemiş.` (The sales line cannot be saved
with these values: no value has been entered for the characteristic 'Kabin Eni'.) and
`2. satırın miktar formülü bilinmiyor — okuduğu değerlerden biri konfigürasyonda yok (KABIN_EN * KABIN_BOY * 2 * 15.7).`
(The quantity formula of line 2 is unknown — one of the values it reads is not in the configuration.)

### Example 10 — Fixed + characteristic-dependent count (terminal blocks) {#ornek-10}

**Requirement:** 4 terminal blocks per output, plus 2 extra for ground.
**Characteristic:** `CIKIS_SAYISI` (number of outputs; Tam Sayı (Integer), 1–24). **Line:** HAM-0014 Klemens (terminal
block), ADET, **Miktar** `2`, formula `4 * CIKIS_SAYISI`.

| CIKIS_SAYISI | Result |
|---|---|
| 4 | 18 ADET |
| 6 | 26 ADET |
| 14 | 58 ADET |
| 20 | 82 ADET |

The same result is obtained with the **Özellik × katsayı** (Characteristic × coefficient) mode: characteristic **Çıkış
Sayısı** (Number of Outputs), coefficient `4`, Miktar `2`.

### Example 11 — Tiered quantity (cable) {#ornek-11}

**Requirement:** 3 m of cable per output for the first 6 outputs, 2 m for the rest.
**Line:** HAM-0024 Kablo NYAF 2,5 mm² (cable NYAF 2.5 mm²), M, **Miktar** `0`, formula
`EGER(CIKIS_SAYISI <= 6, 3 * CIKIS_SAYISI, 18 + 2 * (CIKIS_SAYISI - 6))`.

| CIKIS_SAYISI | Result |
|---|---|
| 4 | 12 M |
| 6 | 18 M |
| 14 | 34 M |
| 20 | 46 M |

For three tiers, nest `EGER`: `EGER(X <= 6, …, EGER(X <= 12, …, …))`.

### Example 12 — EGER protecting a characteristic that is not asked (DIN rail) {#ornek-12}

**Requirement:** 1.2 m of rail in the standard cabinet; for a custom size, width × 2, rounded up to the half meter.
**Line:** HAM-0021 DIN ray (DIN rail), M, **Miktar** `0`, formula
`EGER(KABIN = 'STD', 1.2, YUKARIYUVARLA(KABIN_EN * 2, 0.5))`.

| Kabin | KABIN_EN | Result |
|---|---|---|
| Standart | not asked | 1.2 M |
| Özel Ölçü | 1.2 | 2.5 M (2.4 → 2.5) |

`EGER` evaluates only the selected branch: in the standard cabinet no error occurs even though `KABIN_EN` is unknown.
**Common mistake:** `YUKARIYUVARLA(KABIN_EN * 2, 0.5)` on its own — in the standard cabinet it is unknown and the order
is not opened.

### Example 13 — VEYA and its complement with DEĞİL (PLC or relay module) {#ornek-13}

**Requirement:** PLC module in the professional series or with more than 12 outputs, relay module otherwise.
**Lines:** YM-0009 PLC modülü (PLC module) — `SALT_SERISI = 'PRO' VEYA CIKIS_SAYISI > 12`; YM-0008 Röle modülü (relay
module) — `DEĞİL (SALT_SERISI = 'PRO' VEYA CIKIS_SAYISI > 12)`.

| Şalt Serisi (Switchgear Series) | CIKIS_SAYISI | YM-0009 | YM-0008 |
|---|---|---|---|
| Ekonomik (Economy) | 6 | Not included | 1 ADET |
| Ekonomik (Economy) | 14 | 1 ADET | Not included |
| Profesyonel (Professional) | 4 | 1 ADET | Not included |

Writing the complement with `DEĞİL ( … )` guarantees that the two lines never overlap and that no value is left
uncovered.
**Common mistake:** `DEĞİL SALT_SERISI = 'PRO' VEYA CIKIS_SAYISI > 12` without parentheses — `DEĞİL` applies only to the
first comparison.

### Example 14 — Short-circuit of VE (panel fan) {#ornek-14}

**Requirement:** A fan for a custom cabinet larger than 1.5 m².
**Line:** HAM-0019 Pano fanı (panel fan) — `KABIN = 'OZEL_OLCU' VE KABIN_EN * KABIN_BOY > 1.5`.

| Kabin | Width × Length | Result |
|---|---|---|
| Standart | not asked | Not included — `koşul Hayır` (condition No; even though the size is unknown) |
| Özel Ölçü | 1.2 × 1.6 = 1.92 | 1 ADET |

`HAYIR VE ?` returns No; that is why the standard cabinet shows a plain "No" instead of "value not entered".

### Example 15 — Characteristic × coefficient mode (circuit breaker) {#ornek-15}

**Requirement:** One circuit breaker per output.
**Line:** HAM-0008 Sigorta otomat C10 (circuit breaker C10), ADET, **Miktar** `0`, mode **Özellik × katsayı**
(Characteristic × coefficient): characteristic **Çıkış Sayısı** (Number of Outputs), coefficient `1`.

| CIKIS_SAYISI | Result (calculation shown in Try) |
|---|---|
| 6 | 6 ADET (`1 × Çıkış Sayısı (6) = 6`) |
| 14 | 14 ADET |

In **İfade** (Expression) mode, `1 * CIKIS_SAYISI` gives the same result. In Characteristic × coefficient mode the
coefficient must be greater than zero (`Formül katsayısı sıfırdan büyük olmalıdır.` — The formula coefficient must be
greater than zero.); the mode and an expression cannot be used together
(`Miktar ya özellik × katsayı ya da ifadeli formülle hesaplanır — ikisi birden olmaz.` — The quantity is calculated
either with characteristic × coefficient or with an expression formula — not both.).

### Example 16 — Quantity with a lower limit (busbar) {#ornek-16}

**Requirement:** In the professional series, 5 cm of busbar per output, at least 0.6 m.
**Line:** HAM-0020 Bakır bara (copper busbar), M — option condition **Şalt Serisi: Profesyonel** (Switchgear Series:
Professional), **Miktar** `0`, formula `MAX(0.6, CIKIS_SAYISI * 0.05)`.

| Şalt Serisi (Switchgear Series) | CIKIS_SAYISI | Result |
|---|---|---|
| Profesyonel (Professional) | 4 | 0.6 M |
| Profesyonel (Professional) | 20 | 1 M |
| Ekonomik (Economy) | 14 | Not included |

For an upper limit use `MIN(upper, …)`; for both, `MIN(upper, MAX(lower, …))`.

### Example 17 — Recipe proportional to the batch quantity (chemicals) {#ornek-17}

**Requirement:** Raw materials in proportion to how many kg one batch (1 ADET) produces; salt rounded to one decimal.
**Characteristic:** `PARTI_KG` (batch kg; Ondalık (Decimal), kg, 100–2000, step 50). **Lines:** HAM-0070 SLES —
`PARTI_KG * 0.12`; HAM-0071 Tuz (salt) — `YUVARLA(PARTI_KG * 0.015, 1)`; HAM-0075 Saf su (purified water) —
`PARTI_KG * 0.865` (all with **Miktar** `0`).

| PARTI_KG | SLES | Salt | Water |
|---|---|---|---|
| 500 | 60 KG | 7.5 KG | 432.5 KG |
| 1250 | 150 KG | 18.8 KG (18.75 → 18.8) | 1081.25 KG |

> **Proportional scaling does not require a formula**
For a recipe that only grows proportionally, set the BOM's **Temel Miktar** (Base Quantity) to the batch (e.g. 1000 KG)
and enter the order quantity as the kg to be produced; every line scales with the order quantity automatically. A
formula is needed for the **non-proportional** part: a rounded packaging count, an option-dependent additive.

### Example 18 — Packaging count and cartons (packing) {#ornek-18}

**Requirement:** 5 L canister (5.2 kg fill) or 1 L bottle (1.04 kg); canisters go into cartons of 4, bottles into
cartons of 12.
**Characteristic:** `AMBALAJ` (packaging; Seçim (Selection): **5 L bidon** (5 L canister) `B5L`, **1 L şişe** (1 L
bottle) `S1L`). **Lines** (all with **Miktar** `0`):

| Line | Option condition | Formula |
|---|---|---|
| AMB-0001 Bidon 5 LT (canister 5 L) | Ambalaj: 5 L bidon | `TAVAN(PARTI_KG / 5.2)` |
| AMB-0004 Bidon kapağı (canister cap) | Ambalaj: 5 L bidon | `TAVAN(PARTI_KG / 5.2)` |
| AMB-0007 Koli 4'lü (carton of 4) | Ambalaj: 5 L bidon | `TAVAN(TAVAN(PARTI_KG / 5.2) / 4)` |
| AMB-0002 Şişe 1 LT (bottle 1 L) | Ambalaj: 1 L şişe | `TAVAN(PARTI_KG / 1.04)` |
| AMB-0008 Koli 12'li (carton of 12) | Ambalaj: 1 L şişe | `TAVAN(TAVAN(PARTI_KG / 1.04) / 12)` |

| PARTI_KG | Ambalaj (Packaging) | Canister | Cap | Carton of 4 | Bottle | Carton of 12 |
|---|---|---|---|---|---|---|
| 500 | 5 L bidon | 97 | 97 | 25 | Not included | Not included |
| 1250 | 1 L şişe | Not included | Not included | Not included | 1202 | 101 |

**Common mistake:** Writing the carton count as `TAVAN(PARTI_KG / 5.2 / 4)` — dividing into cartons before rounding the
canisters to a whole number can result in too few cartons. Use nested `TAVAN`.

### Example 19 — Option-dependent additive (fragrance) {#ornek-19}

**Line:** HAM-0072 Parfüm (fragrance), KG, **Miktar** `0`, expression condition `PARFUM = EVET`, formula
`PARTI_KG * 0.003`.

| PARTI_KG | PARFUM | Result |
|---|---|---|
| 1250 | Yes | 3.75 KG |
| 500 | not entered | Not included — `koşulun okuduğu değer girilmedi: PARFUM = EVET` (the value read by the condition was not entered) |

### Example 20 — Panel area and color by dimensions (cabinet) {#ornek-20}

**Requirement:** Body: two sides (height × 60 cm depth), top, bottom and one shelf every 40 cm (width × 60 cm); the
color selects the panel item. 10% cutting scrap.
**Characteristics:** `GEN_CM`, `YUK_CM` (width, height; Tam Sayı (Integer), cm), `RENK` (color; Seçim (Selection)),
`KAPAK` (door; Seçim (Selection)).
**Lines:** HAM-0038 / HAM-0039 / HAM-0040 Melamin sunta Beyaz / Ceviz / Antrasit (melamine chipboard White / Walnut /
Anthracite), M2, **Bileşen firesi** (Component scrap) 10% — option condition **Renk: Beyaz** / **Ceviz** /
**Antrasit**, **Miktar** `0`, formula `(2 * YUK_CM * 60 + (TABAN(YUK_CM / 40) + 1) * GEN_CM * 60) / 10000`.

| Width × Height | Renk (Color) | Line included | Result |
|---|---|---|---|
| 120 × 200 | Ceviz (Walnut) | HAM-0039 | 6.72 M2 |
| 180 × 160 | Beyaz (White) | HAM-0038 | 7.32 M2 |

Use `/ 10000` for cm² → m². Back panel (HAM-0041 MDF) `GEN_CM * YUK_CM / 10000`: 120 × 200 → 2.4 M2.

### Example 21 — Hinges by number of doors and height (cabinet) {#ornek-21}

**Lines:** HAM-0045 Menteşe (hinge) — option condition **Kapak Tipi: Menteşeli** (Door Type: Hinged), formula
`EGER(YUK_CM > 180, 4, 3) * TAVAN(GEN_CM / 60)`; HAM-0046 Kulp (handle) — no condition, formula
`EGER(KAPAK = 'SURGULU', 2, TAVAN(GEN_CM / 60))`; HAM-0033 Profil (sürgü rayı) (profile, sliding rail) — **Kapak Tipi:
Sürgülü** (Door Type: Sliding), formula `2 * GEN_CM / 100`; HAM-0049 Ayar ayağı (leveling foot) —
`EGER(GEN_CM > 120, 6, 4)`.

| Width × Height | Kapak (Door) | Hinge | Handle | Rail | Foot |
|---|---|---|---|---|---|
| 120 × 200 | Menteşeli (Hinged) | 8 | 2 | Not included | 4 |
| 180 × 160 | Sürgülü (Sliding) | Not included | 2 | 3.6 M | 6 |

### Example 22 — BOM with option conditions only (office desk, MAM-0003) {#ornek-22}

A product that needs no formula, where the quantity of every combination is fixed: the panel item is selected from the
combination of **Renk** (Color) × **Masa Genişliği** (Desk Width) (nine lines, each with one value on each of two
characteristics); the edge band reads only the color.

| Masa Genişliği (Desk Width) | Renk (Color) | Kablo Kanalı (Cable Duct) | Panel included | Band | Duct |
|---|---|---|---|---|---|
| 140 cm | Beyaz (White) | Var (Yes) | HAM-0038 1.47 M2 (`Renk Beyaz, Masa Genişliği 140 cm`) | HAM-0042 6 M | HAM-0048 1 ADET |

### Example 23 — The same item on two mutually exclusive lines (tank, MAM-0006) {#ornek-23}

HAM-0031 3 mm sheet is on two lines: **Tank Hacmi: 2.000 L** (Tank Volume: 2,000 L) → 290 KG, **Tank Hacmi: 5.000 L**
(Tank Volume: 5,000 L) → 560 KG. This is allowed because the conditions on the same characteristic do not overlap.
HAM-0034 pipe is on a single line with **1.000 L / 2.000 L** (OR) → 4 M.

| Tank Hacmi (Tank Volume) | Karıştırıcı (Agitator) | HAM-0031 | HAM-0034 | HAM-0059 / HAM-0060 |
|---|---|---|---|---|
| 2.000 L | Var (Yes) | 290 KG | 4 M | 1 / 1 ADET |

### Example 24 — Super routing: duration and operation selection (conveyor) {#ornek-24}

The routing of DMO-KSL-01; durations on order **UE-2026-000009**, opened with BOY 12.5, Bant Tipi (Belt Type) PVC and
Koruma (Protection) Yes:

| Op. | Operation | Rule | Duration on the order |
|---|---|---|---|
| 10 | Profil kesim (profile cutting) | Machine formula `2 * BOY * 0.8` (setup 10, labor 5 fixed) | Machine 20 min |
| 20 | Şase ve makara montajı (chassis and roller assembly) | Labor formula `30 + 6 * BOY` | 105 min |
| 30 | Bant montajı ve gerdirme (belt assembly and tensioning) | Labor formula `EGER(BANT_TIPI = 'PU', 40, 25) + 2 * BOY` | 50 min |
| 40 | Koruma kapağı montajı (protective cover assembly) | Selection condition `KORUMA = EVET`, labor `3 * BOY` | 37.5 min |
| 50 | Motor bağlantısı (motor connection) | Fixed 30 | 30 min |
| 60 | Çalışma testi (operating test) | Labor `EGER(BOY > 10, 30, 20)` | 30 min |

In the panel routing (DMO-KSL-02), the labor of the cabinet fabrication included with `KABIN = 'OZEL_OLCU'` is
`60 + 40 * KABIN_EN * KABIN_BOY` → 136.8 min for 1.2 × 1.6 m; `20 + 8 * CIKIS_SAYISI` → 132 min for 14 outputs; the PLC
programming operation is included with `SALT_SERISI = 'PRO' VEYA CIKIS_SAYISI > 12` (UE-2026-000010).

### Example 25 — Constraint (disallowed combination) {#ornek-25}

**Requirement:** The PU food-grade belt is produced at most 20 m long.
**Rule:** **Sınır koy** (Set a limit), expression `BANT_TIPI <> 'PU' VEYA BOY <= 20`, message
`PU gıda bandı en çok 20 m boyda üretilir.` (The PU food-grade belt is produced at most 20 m long.)

| Bant Tipi (Belt Type) | BOY | Result |
|---|---|---|
| PU | 24 | The sales line is not saved — `PU gıda bandı en çok 20 m boyda üretilir.` |
| PU | 12.5 | Passes |
| PVC | 24 | Passes |

An out-of-range value does not need a constraint; the characteristic's **En az / En çok / Adım** (Minimum / Maximum /
Step) fields check it: `'Boy' değeri izinli aralıkta değil (2–30 m, 0,5 m adım).` (The value of 'Boy' is not within
the allowed range (2–30 m, step 0.5 m).) (BOY 31 or 6.3).

## Checklist for writing rules

1. Write **whether** the line is included with a condition and its **quantity** with a formula; do not combine the two
   inside `EGER(…, …, 0)`.
2. On a formula line, fill in the **Miktar** (Quantity) field deliberately (usually `0`).
3. Write option codes in single quotes and Yes/No without quotes; use a dot as the decimal separator.
4. Build rules that read optional characteristics and characteristics with preconditions for the "no value" case
   (`DOLU`, `EGER`).
5. Write limits so that they cover every value: one side `<=`, the other `>`; for the complement use `DEĞİL ( … )`.
6. If the same item is needed on two lines, set up the conditions so that they exclude each other **by option**; an
   expression condition is not enough.
7. Before saving, use **Sına** (Test); after saving, use **Yapılandırarak Dene** (Try by Configuring) to try the extreme
   values (smallest, largest, both sides of a limit, optional field blank).

## Related

- [Define a line rule](https://erpdocs.corexlogic.com/en/uretim/islemler/satir-kurali-tanimlama)
- [Try by configuring](https://erpdocs.corexlogic.com/en/uretim/islemler/yapilandirarak-deneme)
- [Define a precondition](https://erpdocs.corexlogic.com/en/uretim/islemler/on-kosul-tanimlama)
- [Write a super routing rule](https://erpdocs.corexlogic.com/en/uretim/islemler/super-rota-kurali-yazma)
- [Configurable products](https://erpdocs.corexlogic.com/en/uretim/ekranlar/yapilandirilabilir-urunler)
- [Order to production process](https://erpdocs.corexlogic.com/en/surecler/siparisten-uretime)