Skip to content

Importing threads from CSV

The CSV importer turns a spreadsheet into Threads — one Thread per row. It lives at Threads → Import Threads and takes three steps: File, Fields, then Import. The steps show at the top of the page with what each one settled (the file name, the number of fields and how many are private), and Back and Continue stay in the bar at the bottom of the screen. The bar also keeps a running count: how many Threads are ready, how many values will be left out and how many rows won’t import.

The first row holds the column names; every row after it becomes one Thread. Keep a column for the Thread name — DICE suggests a Name/Title column when it finds one, and otherwise picks the first. Only .csv files are accepted. No file yet? Download an example CSV on the first step gives you one to start from.

Drop the file on the page or click Choose file. Once it is read, DICE shows the file name, its row and column counts and its first rows, so you can check it is the right file before going on. Replace file reads a different one.

Fields come either from this file’s columns or from a saved template. DICE picks a template for you only when the file is exactly in its shape: every field of the template has a column, and every column is one of its fields or the name, description or kind column the template remembers. Any other file starts with its own columns, with the choice open so you can pick a template yourself. Choose Change to switch. With a template selected, Sample CSV downloads a file with that template’s columns.

When the template doesn’t use every column of your file, the unused columns are listed under the fields. Their data isn’t imported unless you choose Add to make one a new field — or, while no column is the description, Use as description. A field you add is marked Added; Remove takes it back out.

Each Thread takes its name — and, optionally, its description — from a column. DICE picks them for you; choose Change to pick others. These columns aren’t added as fields, because the Thread carries them itself. Tick Also keep these columns as fields to store them in the field data too. A template remembers which columns its last import used for the name and description, so the next file with the same headers starts from them.

If some rows have an empty name cell, DICE lists them. Those rows won’t import unless you pick another column under When the name is empty, use — for example a serial number — to name them instead.

With the Assemblies module, choose under Each row becomes whether each row becomes a Thread or an Assembly. For a file that mixes them — a bill of materials, say — pick a column under Or read it from a column: a cell reading “assembly” or “unit” decides its row, and a blank cell or any other value takes the choice above; DICE says how many rows that is. A column headed “Kind” is picked for you. Like the name and description columns, the kind column isn’t added as a field, and a template remembers both choices for its next import.

  • With fields from your file, tick Save as template on the Fields from this file’s columns row to reuse them — with their types and privacy — next time, and give the template a name. It is off by default, so a one-off file doesn’t leave a template behind.
  • With a saved template, a field you change is marked Changed. Tick Save N changes to the template on the template’s row to keep them for later imports and new Threads; otherwise they apply to this import only.

Nothing — Threads or template — is saved until you choose Import.

Set each field’s name, type, privacy and whether it’s required

Section titled “Set each field’s name, type, privacy and whether it’s required”

Every field is listed with the column it reads and an example value. For each one you can:

  • leave it out of the import (untick it, or choose Don’t import for a template’s field);
  • rename it;
  • change its Type — for example from Text to Number. Turning a field into a Select fills its options with the values found in the column;
  • make it Private. Private fields stay with the owning team and are left out when a Thread is shared. Make all private sets every field at once;
  • make it Required.

When the fields come from a template, a field you change shows Changed, with Reset to template to undo it. Fields from a file start optional, even when every row has a value.

DICE checks every row against your settings as you change them, and says right under a field when a value can’t be imported — naming the rows and the values:

  • A value that doesn’t fit the field’s type (say “pending” in a Number field) is left out: the Thread is still created, without that value.
  • If the field is Required, a row with a missing or unfitting value won’t import at all.

Each warning offers the fix in place — Switch back to Text, or Turn off Required.

Choose the Folder the Threads go to. The picker pre-fills your most recently used folder. The line under it names the organization and team that will own the Threads — a folder shared with you belongs to another team, and Threads created in it belong to that team, not yours.

Before you import, DICE sums up the result: the number of Threads to create, the fields each will have (and how many are private), how many values will be left out and how many rows won’t import. Each problem is listed with the rows it affects (Show the row) and a Fix button that takes you back to that field. Columns of your file that no field reads are named too.

The Preview shows how the first rows will look as Threads, field by field, with private fields marked. A row with a problem is always included, so you can see exactly what will be left out. With the Assemblies module, each card also says whether its row becomes an Assembly, and Threads to create counts how many will.

Choose Import N Threads. A progress bar shows how far it has got; keep the page open until it finishes. Stop import stops after the rows already sent — the rest are listed on the result as not sent, ready to send later. If you try to leave the page while importing, or after you’ve changed fields, DICE asks first.

If some rows weren’t created, the result names each one and why. Try N rows again resends the rows the server didn’t accept, and Download those rows as CSV gives you just those rows to fix and import again. The result also recaps any values that were left out. Open goes to the folder.

A successful import records an Imported Thread activity group per Thread in the activity feed.

Separately from CSV import, DICE can import an Assembly Import Package — a JSON file describing Threads, assemblies, part attachments, and relationship links in one structure. It lives at Assemblies → Import assembly package.

  1. Paste the package JSON or Load file.
  2. Click Validate package. The package is dry-run into an Import plan: counts of Threads, Assemblies, Non-assembly Threads, Thread attachments, and Thread links to be created, plus any Blocking issues and Warnings. Referenced folders, categories, and relationships are matched against what already exists and marked reuse existing, create new, or flagged as ambiguous.
  3. When the plan reads “This package is ready to import.”, click Commit import.

Unlike CSV import, the assembly package import is transactional: “nothing is written until you commit, and the import is all-or-nothing.” Resolve any blocking issues before committing. See Assemblies for what assemblies and parts are.