Property Calculator Calculation Modes

Overview

Each property calculation rule has a Mode that determines what kind of operation it performs. There are 16 available modes:

Quick Start: New to Property Calculator? Most configurations only need a handful of these modes. Start with Calculate Expression (computing values from other properties), Set Static Values (setting a fixed value on a condition), and Count Date Or Time (deadline/date math) — together these cover the majority of everyday calculation rules. The rest are for more specific needs.

Calculate Expression

The most commonly used mode. Evaluates a text expression and saves the result to the target property.

Use when: You need to compute or combine a value from other properties — the default choice for most calculated properties, whether that’s arithmetic, string building, or conditional logic via NCalc functions.

Simple placeholder mode (Evaluate as Expression = OFF):

Invoice %PROPERTY_{PD.InvoiceNumber}% - %PROPERTY_{PD.CustomerName}%

Result: Invoice 12345 - Acme Corp

NCalc expression mode (Evaluate as Expression = ON):

%PROPERTY_{PD.Quantity}% * %PROPERTY_{PD.UnitPrice}% * (1 + 0.24)

Result: 6200 (if quantity=20, price=250)

See NCalc Expressions for complete expression syntax and Examples for practical examples.

Set Static Values

Directly sets a specific value to a property — no expression evaluation needed.

Use when: You need to set a fixed lookup value, a specific date, or a constant text value based on conditions.

Example — Set reviewer on approval: When a document reaches “Approved” state, set PD.ApprovedBy to user lookup ID 42.

Example — Clear a property: When status changes to “Draft”, set PD.Manager to NULL (remove the assignment).

Example — Append to MSLU: With Keep Previous Content ON, add a lookup value to an existing multi-select list without clearing previous selections.

Pick Substring

Extracts portions of text using regular expressions and saves them to one or more target properties. Can also modify the source string by removing extracted parts.

Use when: You need to parse structured text into separate properties (e.g., split a filename, extract codes from a title, parse imported text fields).

Substring extraction rules:

Example — Parse “INV-2026-0042 Acme Corp”:

Source:     %PROPERTY_{PD.RawTitle}%

Substring 1:
  Condition: Pick first founded RegExp
  RegExp:    INV-\d{4}-\d+
  Save To:   PD.InvoiceNumber
  → Result:  "INV-2026-0042"

Substring 2:
  Condition: Pick text until RegExp
  RegExp:    $  (end of string)
  Save To:   PD.CustomerName
  → Result:  " Acme Corp"

Example — Extract with named group:

Source:     %PROPERTY_{PD.Code}%
RegExp:    PRJ-(?<value>\d+)-[A-Z]+
Pick Only Subexpression: ✅
→ From "PRJ-2026-FIN" extracts "2026"

Remove Property

Removes a property definition from the object entirely — not just clearing the value, but removing the property from the metadata card so it’s no longer visible.

Use when: A property should only exist under certain conditions and should be completely absent otherwise (e.g., remove “Rejection Reason” when status is not “Rejected”).

The target property is the one that gets removed. No additional settings — just the target property and conditions.

Example — Remove rejection fields when approved:

Target Property: PD.RejectionReason
Conditions:
  - Type: Basic Conditions
    Property "PD.Status" NOT equals "Rejected"
→ RejectionReason property disappears from the metadata card for non-rejected objects

Example — Remove optional properties by document type:

Target Property: PD.InvoiceNumber
Conditions:
  - Type: Advanced Conditions
    Expression: lookupName(%PROPERTY_{PD.DocumentType}%) != 'Invoice'
→ InvoiceNumber property is removed from non-invoice documents

The property is removed from the object’s metadata card, not from the vault’s property definition. It can reappear on future check-ins if conditions change.

Convert Date

Converts between text and Date/Time property types using configurable format strings and culture settings.

Use when: You have a date stored as text (e.g., from imported/scanned data) and need it as a proper Date/Time value, or you need to format a date into a specific text representation.

Example — Parse Finnish date:

Conversion Type: String to Date
Value From:      PD.DateText        → "15.01.2026"
String Format:   dd.MM.yyyy
Language:        fi-FI
→ Result:        2026-01-15T00:00:00 (DateTime)

Example — Format date for display:

Conversion Type: Date to String
Value From:      PD.Created          → 2026-05-07T14:30:00
String Format:   d. MMMM yyyy
Language:        fi-FI
→ Result:        "7. toukokuuta 2026"

For simple date arithmetic, use Count Date Or Time or Calculate Expression with dateAdd() instead.

Count Date Or Time

Adds or subtracts time units from a base date/time. Supports multiple chained operations and can use either fixed values or values from other properties.

Use when: You need to calculate deadlines, expiration dates, or scheduled dates with straightforward add/subtract logic.

Each operation:

Example — Due date 30 days after invoice:

Base Date:  PD.InvoiceDate
Operations:
  1. Increase by 30 Days (Fixed)
→ Invoice date 2026-01-15 → Due date 2026-02-14

Example — Business days deadline:

Base Date:  PD.ReceivedDate
Operations:
  1. Increase by 5 Business Days (Fixed)
→ Received Friday 2026-01-10 → Deadline Friday 2026-01-17
  (skips Saturday + Sunday)

Example — Dynamic from metadata:

Base Date:  PD.ContractStart
Operations:
  1. Increase by [PD.ContractMonths] Months (From Metadata)
→ Start 2026-01-01, ContractMonths=12 → End 2027-01-01

Example — Multiple operations chained:

Base Date:  PD.ProjectStart
Operations:
  1. Increase by 6 Months (Fixed)
  2. Decrease by 5 Business Days (Fixed)
→ Deadline = 6 months after start, minus 5 business days buffer

For more complex date logic (conditional dates, comparisons), use Calculate Expression with dateAdd() function.

Period Length

Calculates the numerical difference between two date properties in configurable time units.

Example — Contract duration in days:

Start Date: PD.ContractStart   → 2026-01-01
End Date:   PD.ContractEnd     → 2026-12-31
Unit:       Day
Modifier:   1
→ Result:   366 days (inclusive of both end dates)

Example — Exact duration (no modifier):

Start Date: PD.StartDate
End Date:   PD.EndDate
Unit:       Day
Modifier:   0
→ End 2026-01-31 − Start 2026-01-01 = 30 days

Example — Hours between timestamps:

Start Date: PD.CheckInTime
End Date:   PD.CheckOutTime
Unit:       Hour
Modifier:   0
→ 14:00 − 08:00 = 6 hours

For period calculations in months or years, use Calculate Expression mode with dateDiff() function.

Filter Lookup Values

Removes lookup values from a Multi-Select Lookup property that don’t match specified filtering conditions. The conditions are evaluated against each linked object — those that fail are removed from the MSLU.

Use when: You want to automatically clean up MSLU values based on the current state of referenced objects (e.g., keep only active items).

Example — Keep only active contracts:

Lookup Values From: PD.RelatedContracts
Conditions:
  - Type: Basic Conditions
    Property "Status" equals "Active"
→ Removes any contract from the MSLU whose Status ≠ Active

Example — Keep only items with value > 0:

Lookup Values From: PD.InvoiceLines
Conditions:
  - Type: Advanced Conditions
    Expression: %PROPERTY_{PD.Amount}% > 0
→ Removes zero-value line items from the list

Order Lookup Values

Reorders items in a Multi-Select Lookup property according to configurable sort criteria. Can sort alphabetically or numerically, by any property of the linked objects.

Use when: The display order of MSLU items matters (e.g., sorted by date, name, priority, or amount).

Example — Sort line items by amount (highest first):

Lookup Values From: PD.InvoiceLines
Order Type:         Numerical
Reverse Order:      ✅
Order By:           %PROPERTY_{PD.Amount}%
Amount of Lookups:  0
→ Lines sorted from highest to lowest amount

Example — Keep top 5 by date:

Lookup Values From: PD.RelatedDocuments
Order Type:         Alphabetical  (dates sort alphabetically in ISO format)
Reverse Order:      ✅
Order By:           %PROPERTY_{PD.Created}%
Amount of Lookups:  5
→ Keeps only the 5 most recently created documents

Values From MSLU

Collects property values from all objects referenced in a Multi-Select Lookup and writes the aggregated result to the target property. Can filter which linked objects contribute.

Use when: You need to gather data from multiple related objects into a single property (e.g., collect all descriptions, concatenate names, merge lookup values).

The target property receives the collected values. For text properties, values are concatenated. For MSLU properties, lookup values are merged.

Example — Collect all task names into a text field:

Multi-Select Lookup:          PD.ProjectTasks
Target Property:              PD.TaskSummary
Conditions for Listed Object: (none — include all)
→ Result: "Design, Development, Testing, Deployment"

Example — Collect active members only:

Multi-Select Lookup:          PD.TeamMembers
Target Property:              PD.ActiveMembers
Conditions for Listed Object:
  - Type: Basic Conditions
    Property "Status" equals "Active"
→ Only active team members appear in the result

For numeric aggregation (sum, average, etc.) over MSLU values, use Calculate Expression with chained placeholders and aggregation functions instead.

Search Objects

Searches the vault for objects or value list items matching specified conditions and saves the results as a lookup property value. Supports both object searches and value list item lookups.

Use when: You need to dynamically find and link objects based on property matches, or resolve value list items by name/external ID.

Example — Find invoices for the same customer:

Target Property:      PD.RelatedInvoices (MSLU)
Search Value List Items: ❌
Property Conditions:
  - Object Type = Invoice
  - PD.Customer equals %PROPERTY_{PD.Customer}%
Max Results:          10
→ Populates MSLU with up to 10 invoices for the same customer

Advanced options

Concept — version-specific references: By default, a saved lookup follows the latest version of its target object as that object keeps changing. Enabling a version-specific option instead pins the reference to the exact version that existed when the calculation ran, so the metadata card keeps pointing at that historical version even after the target object is edited further. This mechanism is shared by Add version-specific reference here, Source Version Reference Is Version-Specific in History, and the lookupVersion() NCalc function.

Create Object

Creates a new M-Files object with configured property values. Can create from scratch or as a copy of an existing object. Supports creating multiple objects from value combinations.

Use when: You need to automatically generate new objects based on existing object data (e.g., create a task when a document reaches a specific state, generate sub-items from a template).

Example — Create task from document:

Create as Copy: ❌
Object Type:    Task
Create Only If Does Not Exist: ✅
Duplicate Detection:
  - PD.SourceDocument = %PROPERTY_{PD.ObjectID}%
Other Property Values:
  - PD.TaskName       = "Review: %OBJTITLE%"
  - PD.AssignedTo     = %PROPERTY_{PD.Reviewer}%
  - PD.DueDate        = (calculated separately)
  - PD.SourceDocument = %PROPERTY_{PD.ObjectID}%
Conditions:
  - Status changes to "Pending Review"
→ Creates one task per document, prevents duplicates

This operation creates real objects in the vault. Use Create Only If Does Not Exist and test conditions carefully to avoid creating duplicate objects on repeated check-ins.

Advanced options

These settings apply to the less common “copy as template” and “split into multiple objects” variants of Create Object:

History

Copies property values and/or files from a previous version of the current object. Can target a specific version based on conditions and map source properties to different target properties.

Use when: You need to preserve or restore values from previous versions (e.g., track original submission date, restore overwritten values, archive historical data).

Property Mapping:

Example — Preserve original submission date:

Conditions for Source Version:
  - Type: Basic Conditions
    Property "PD.Status" equals "Submitted"  (find first version in Submitted state)
Property Mappings:
  - Source: %PROPERTY_{PD.SubmissionDate}% → Target: PD.OriginalSubmissionDate
Throw Exception: ❌
→ Copies the submission date from the version when the object was first submitted

Advanced options

File Operation

Renames files attached to an object by adding a prefix and/or postfix to the filename. All naming fields support placeholders.

Use when: You need to rename files based on metadata values (e.g., add document number as prefix, append revision to filename).

Example — Add document number as prefix:

Prefix:    %PROPERTY_{PD.DocumentNumber}% -
Postfix:   (empty)
Always Add: ❌
→ "Report.pdf" → "DOC-2026-0042 - Report.pdf"
→ Next check-in: unchanged (prefix already present)

Example — Add revision as postfix:

Prefix:    (empty)
Postfix:    _Rev%PROPERTY_{PD.Revision}%
Always Add: ✅
→ "Drawing.dwg" → "Drawing_RevC.dwg"
→ Next check-in with Rev D: "Drawing_RevC_RevD.dwg" (Always Add = ON)

Example — Full rename:

Prefix:    %PROPERTY_{PD.ProjectCode}% -
Postfix:    - v%PROPERTY_{PD.Version}%
Always Add: ❌
→ "Specification.docx" → "PRJ-2026 - Specification - v3.docx"

Send Email

Sends an email message with configurable recipients, subject, and body. All text fields support placeholders, allowing dynamic content from the current object.

Use when: You need automated email notifications triggered by object changes (e.g., approval notifications, deadline alerts).

Example — Approval notification:

Allow Email Sending: ✅
To:      %PROPERTY_{PD.Approver}.PROPERTY_{PD.Email}%
Subject: Approval Required: %OBJTITLE%
Body:    <h2>Document Pending Approval</h2>
         <p>Document <b>%OBJTITLE%</b> requires your approval.</p>
         <p>Submitted by: %PROPERTY_{PD.SubmittedBy}%</p>
         <p>Amount: %PROPERTY_{PD.Amount}% EUR</p>
Conditions:
  - Status changes to "Pending Approval"

Example — Deadline warning:

To:      %PROPERTY_{PD.ProjectManager}.PROPERTY_{PD.Email}%
Subject: ⚠️ Contract expiring: %OBJTITLE%
Body:    Contract %OBJTITLE% expires on %PROPERTY_{PD.EndDate}%.
         Please review and take action.
Conditions:
  - Advanced Condition: dateDiff(today(), %PROPERTY_{PD.EndDate}%, 'days') <= 30

Email sending is a side effect. The Expression Builder does NOT send emails — they are only sent during actual check-in processing.

Grouping Level

Creates a named sub-group of property calculations for organizational purposes. The group itself does not perform any calculation — it acts as a container with its own conditions.

Use when: You have many related calculations that benefit from being grouped together with a descriptive name, or when you want shared conditions for a block of rules.

Example — Group invoice line calculations:

Grouping Level: "Line Item Calculations"
  Conditions:
    - Changed Propertyvalues: PD.Quantity, PD.UnitPrice
  Properties:
    ├─ Rule 1: Calculate Line Total
    ├─ Rule 2: Calculate Tax Amount
    └─ Rule 3: Calculate Line Grand Total
→ All three rules only execute when Quantity or UnitPrice changes

This is purely organizational — the same rules could be placed at the top level. But grouping keeps complex configurations readable and allows shared conditions.