@processpuzzle/base-entity 1.2.2 → 1.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +116 -15
- package/assets/i18n/base_entity/de.json +166 -1
- package/assets/i18n/base_entity/en.json +166 -1
- package/assets/i18n/base_entity/es.json +166 -1
- package/assets/i18n/base_entity/fr.json +166 -1
- package/assets/i18n/base_entity/hu.json +166 -1
- package/fesm2022/processpuzzle-base-entity.mjs +15154 -4329
- package/fesm2022/processpuzzle-base-entity.mjs.map +1 -1
- package/package.json +5 -2
- package/types/processpuzzle-base-entity.d.ts +3835 -795
- package/types/processpuzzle-base-entity.d.ts.map +1 -1
package/README.md
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# @processpuzzle/base-entity
|
|
2
2
|
|
|
3
3
|

|
|
4
|
-
[](https://sonarcloud.io/summary?id=processpuzzle_base_entity_frontend)
|
|
5
|
+
[](https://www.npmjs.com/package/@processpuzzle/base-entity)
|
|
6
6
|
|
|
7
7
|
## Introduction
|
|
8
8
|
|
|
@@ -47,7 +47,7 @@ To plug the library into your application you provide an entity class, a mapper,
|
|
|
47
47
|
<img src="https://github.com/ZsZs/processpuzzle/blob/develop/docs/base-entity-design_overview.png?raw=true" width=600px alt="Design Overview">
|
|
48
48
|
</a>
|
|
49
49
|
|
|
50
|
-
The snippets below are taken from the [TestEntity sample in the testbed](https://github.com/ZsZs/processpuzzle/tree/develop/apps/processpuzzle-testbed/src/app/content/base-forms/test-entity).
|
|
50
|
+
The snippets below are taken from the [TestEntity sample in the testbed](https://github.com/ZsZs/processpuzzle/tree/develop/apps/processpuzzle-testbed-frontend/src/app/content/base-forms/test-entity).
|
|
51
51
|
|
|
52
52
|
### 1. Define your entity
|
|
53
53
|
|
|
@@ -102,13 +102,18 @@ export class TestEntityMapper implements BaseEntityMapper<TestEntity> {
|
|
|
102
102
|
|
|
103
103
|
### 3. Extend the data service
|
|
104
104
|
|
|
105
|
-
Pick `BaseEntityRestService` for an HTTP backend or `BaseEntityFirestoreService` for Firestore. Pass the mapper, a configuration key that resolves to the
|
|
105
|
+
Pick `BaseEntityRestService` for an HTTP backend or `BaseEntityFirestoreService` for Firestore. Pass the mapper, a configuration key that resolves to the root URL, and the resource path.
|
|
106
|
+
|
|
107
|
+
The key is a `BaseConfiguration` property name, resolved through `serviceRootOf`. Use
|
|
108
|
+
`BACKEND_SERVICE_ROOT` for a resource served by the platform's own backend — or the optional
|
|
109
|
+
per-feature root of the owning feature, which falls back to it. Use `THIRD_PARTY_ROOT` for a
|
|
110
|
+
third-party source, as the example below does: `test-entity` is one of the json-server resources.
|
|
106
111
|
|
|
107
112
|
```typescript
|
|
108
113
|
@Injectable({ providedIn: 'root' })
|
|
109
114
|
export class TestEntityService extends BaseEntityRestService<TestEntity> {
|
|
110
115
|
constructor(protected override entityMapper: TestEntityMapper) {
|
|
111
|
-
super(entityMapper, '
|
|
116
|
+
super(entityMapper, 'THIRD_PARTY_ROOT', 'test-entity');
|
|
112
117
|
}
|
|
113
118
|
}
|
|
114
119
|
```
|
|
@@ -132,7 +137,7 @@ export const TestEntityStore = signalStore(
|
|
|
132
137
|
|
|
133
138
|
### 5. Describe the attributes
|
|
134
139
|
|
|
135
|
-
Each visible field gets a `BaseEntityAttrDescriptor` whose `FormControlType` picks the control (full list and behavior in [Control types](#control-types)). Use `FlexboxDescriptor` to lay attributes out in rows and columns, and `linkedEntityType` (a string — the related entity's name) to point at
|
|
140
|
+
Each visible field gets a `BaseEntityAttrDescriptor` whose `FormControlType` picks the control (full list and behavior in [Control types](#control-types)). Use `FlexboxDescriptor` to lay attributes out in rows and columns, and `linkedEntityType` (a string — the related entity's name) to point at another entity (used by `LOOKUP`, `FOREIGN_KEY`, `RELATED_ENTITIES`, `COMPONENTS`, and `EMBEDDED_COMPONENTS`). The descriptor is resolved at runtime through `BASE_ENTITY_FACADE_REGISTRY`.
|
|
136
141
|
|
|
137
142
|
```typescript
|
|
138
143
|
function createTestEntityAttrDescriptors(): AbstractAttrDescriptor[] {
|
|
@@ -144,13 +149,17 @@ function createTestEntityAttrDescriptors(): AbstractAttrDescriptor[] {
|
|
|
144
149
|
const dateAttr = new BaseEntityAttrDescriptor('date', FormControlType.DATE, 'Date', undefined, false, { inputType: 'date' });
|
|
145
150
|
const lookupAttr = new BaseEntityAttrDescriptor('lookup', FormControlType.LOOKUP, 'Lookup');
|
|
146
151
|
const enumAttr = new BaseEntityAttrDescriptor('enumValue', FormControlType.DROPDOWN, 'Enum', selectables);
|
|
152
|
+
const relatedEntitiesAttr = new BaseEntityAttrDescriptor('relatedEntities', FormControlType.RELATED_ENTITIES, 'Related Entities');
|
|
147
153
|
const componentsAttr = new BaseEntityAttrDescriptor('components', FormControlType.COMPONENTS, 'Components');
|
|
154
|
+
const embeddedComponentsAttr = new BaseEntityAttrDescriptor('embeddedComponents', FormControlType.EMBEDDED_COMPONENTS, 'Embedded Components');
|
|
148
155
|
|
|
149
156
|
lookupAttr.linkedEntityType = 'Trunk Data';
|
|
157
|
+
relatedEntitiesAttr.linkedEntityType = 'Related Entity';
|
|
150
158
|
componentsAttr.linkedEntityType = 'Test Entity Component';
|
|
159
|
+
embeddedComponentsAttr.linkedEntityType = 'Embedded Component';
|
|
151
160
|
|
|
152
161
|
const column1 = new FlexboxDescriptor([nameAttr, descriptionAttr, booleanAttr], FlexDirection.COLUMN);
|
|
153
|
-
const column2 = new FlexboxDescriptor([numberAttr, dateAttr, lookupAttr, enumAttr, componentsAttr], FlexDirection.COLUMN);
|
|
162
|
+
const column2 = new FlexboxDescriptor([numberAttr, dateAttr, lookupAttr, enumAttr, relatedEntitiesAttr, componentsAttr, embeddedComponentsAttr], FlexDirection.COLUMN);
|
|
154
163
|
const layout = new FlexboxDescriptor([column1, column2], FlexDirection.CONTAINER);
|
|
155
164
|
layout.style = { 'column-gap': '20px' };
|
|
156
165
|
return [layout];
|
|
@@ -164,6 +173,7 @@ export function createTestEntityDescriptor(): BaseEntityDescriptor {
|
|
|
164
173
|
A few notes:
|
|
165
174
|
|
|
166
175
|
- `linkedEntityType` is just the name of the related entity. The actual `BaseEntityDescriptor` is resolved at runtime through the facade registered in `BASE_ENTITY_FACADE_REGISTRY`.
|
|
176
|
+
- `multiplicity` says how many values an attribute holds: `'0..1' | '0..x' | '0..n' | '1..x' | '1..n'`, where `x` is the attribute's `maxOccurs` and `n` is unbounded. Absent means a single value; the attribute is *multi-valued* when the upper bound exceeds 1 (`isMultiValued()` / `upperBound()` are exported). Only `ARTIFACT` acts on it today, value counts are not validated, and `required` stays a separate flag. A metadata-defined entity carries both fields from its `EntityAttributeDefinition`.
|
|
167
177
|
- `BaseEntityDescriptor` takes an options object (`{ entityName, attrDescriptors, store?, entityTitle? }`); `store` and `entityTitle` are usually set later in the host component.
|
|
168
178
|
|
|
169
179
|
### 6. Render the container
|
|
@@ -229,11 +239,38 @@ Every attribute's `FormControlType` selects the component that renders it in the
|
|
|
229
239
|
| `FLEX_BOX` | layout container | — (no control) | uses `FlexboxDescriptor` | Grouping only; recurses into children. See below. |
|
|
230
240
|
| `LOOKUP` | autocomplete over a lookup table | lookup **`key`** (`string`) | **`linkedEntityType`** | Tricky — see below. |
|
|
231
241
|
| `FOREIGN_KEY` | read-only field + Select/link buttons | related entity **`id`** (`string`) | **`linkedEntityType`** | To-one reference; picks via the navigator. |
|
|
232
|
-
| `
|
|
233
|
-
| `
|
|
242
|
+
| `RELATED_ENTITIES` | list of related-entity rows | array of related **ids** | **`linkedEntityType`**, `referenceIdField` | To-many **association**; the related entities exist independently. |
|
|
243
|
+
| `COMPONENTS` | list of component rows | array of component **ids** | **`linkedEntityType`**, `referenceIdField` | To-many **containment**, child in its own table. Attaching stamps the parent's id into the child's foreign key; deleting destroys the child. |
|
|
244
|
+
| `EMBEDDED_COMPONENTS` | inline sub-form per component | array of the **children themselves** | **`linkedEntityType`** | To-many **containment**, child inside the parent's payload. Backed by a `FormArray`; saved and deleted with the parent. |
|
|
245
|
+
| `ARTIFACT` | file thumbnail/icon + upload/delete | `ArtifactAttr` (or `null`); `ArtifactAttr[]` when multi-valued | `label`, `showThumbnail`, `multiplicity`, `maxOccurs` | Tricky — see below. |
|
|
234
246
|
| `ADDITIONAL_PROPERTIES` | editable key/value list | `Record<string,string>` | `label` | Free-form string map. |
|
|
235
247
|
|
|
236
|
-
`linkedEntityType` is **mandatory** for `LOOKUP`, `FOREIGN_KEY`,
|
|
248
|
+
`linkedEntityType` is **mandatory** for `LOOKUP`, `FOREIGN_KEY`, `RELATED_ENTITIES`, `COMPONENTS`, and `EMBEDDED_COMPONENTS` — it names the other entity, whose descriptor is resolved at runtime through `BASE_ENTITY_FACADE_REGISTRY` (or, for an embedded component, through `EMBEDDED_ENTITY_DESCRIPTOR_REGISTRY`); omitting it throws.
|
|
249
|
+
|
|
250
|
+
### Association vs. containment
|
|
251
|
+
|
|
252
|
+
Three control types render a to-many list, and which one is right follows from **who owns the rows**:
|
|
253
|
+
|
|
254
|
+
| Control type | Relationship | Add | Delete | Persisted by |
|
|
255
|
+
| --- | --- | --- | --- | --- |
|
|
256
|
+
| `RELATED_ENTITIES` | **association** — the target lives on its own | picks an existing entity through the navigator | detaches the reference only | the target's own save, independently |
|
|
257
|
+
| `COMPONENTS` | **containment**, child in its own table | picks/creates a child, then stamps this entity's id into the child's foreign key | destroys the child (after confirmation) | the child's own endpoint |
|
|
258
|
+
| `EMBEDDED_COMPONENTS` | **containment**, child in this payload | appends an empty inline sub-form | drops the row | this entity's save |
|
|
259
|
+
|
|
260
|
+
The two containment types are the two variations of a **component** — a part that belongs to exactly one
|
|
261
|
+
parent — and the child's own descriptor says which it is through `componentParent` / `isEmbedded` (see
|
|
262
|
+
[Component entities](#component-entities)). The declarations are on opposite sides of the relationship and are
|
|
263
|
+
both hand-written, so each control **checks that they agree at first render** and throws, naming both sides,
|
|
264
|
+
when they do not:
|
|
265
|
+
|
|
266
|
+
- the child entity has no descriptor in either registry;
|
|
267
|
+
- the child does not name this entity in its `componentParent`;
|
|
268
|
+
- `COMPONENTS` points at an `isEmbedded` child (use `EMBEDDED_COMPONENTS`), or `EMBEDDED_COMPONENTS` points at
|
|
269
|
+
one that is not (use `COMPONENTS`).
|
|
270
|
+
|
|
271
|
+
`Test Entity` in the [testbed](../../../apps/processpuzzle-testbed-frontend) demonstrates all three side by side —
|
|
272
|
+
`relatedEntities` → `Related Entity`, `components` → `Test Entity Component`, `embeddedComponents` →
|
|
273
|
+
`Embedded Component`.
|
|
237
274
|
|
|
238
275
|
### FLEX_BOX (layout)
|
|
239
276
|
|
|
@@ -243,13 +280,77 @@ Every attribute's `FormControlType` selects the component that renders it in the
|
|
|
243
280
|
|
|
244
281
|
- **`LOOKUP`** uses a **two-control design**: the visible autocomplete text is a private `displayControl` decoupled from the real `FormControl`, which stores the lookup **key**. An `effect()` keeps them in sync. The lookup table (`{ key, value, description? }`) is loaded on init from the store resolved via `linkedEntityType`; the display shows `value`, the form holds `key`. The link icon navigates to the related entity.
|
|
245
282
|
- **`FOREIGN_KEY`** shows the related entity's identifying text (read-only) with the real id in a hidden control. The **Select** button snapshots the form and navigates to the related list (`SELECT_OR_CREATE`); on return the chosen id is written back to both the entity and the control. A link icon navigates to the current reference.
|
|
246
|
-
- **`
|
|
247
|
-
- **`
|
|
283
|
+
- **`RELATED_ENTITIES`** is the to-many analogue: it normalizes heterogeneous items (strings/objects) into `{ id }` using `referenceIdField`, appends via the same navigator round-trip, and each row has a link and a delete button that detaches the reference only.
|
|
284
|
+
- **`COMPONENTS`** looks like `RELATED_ENTITIES` but owns its rows. It resolves each row's text through the child's store (loading it if the parent's form is the first screen opened) and falls back to the id; **Add** takes the same navigator round-trip and then writes the parent's id into the attribute named by the child's `parentReferenceAttrName()`; **Delete** confirms and then calls the child store's `delete`. Like `ARTIFACT`, it therefore has an **immediate backend side-effect**, before the parent is saved.
|
|
285
|
+
- **`EMBEDDED_COMPONENTS`** is the only control backed by a **`FormArray`** rather than a `FormControl`: each row is a sub-form built from the child's descriptor with the same `BaseEntityFormBuilder`, so the children are already part of `form.value` (no imperative write-back) and a child's `required` attribute keeps the *parent's* Save disabled. The sub-forms are handed the **parent's** store — an embedded child has none of its own. Rows are seeded from the attribute's value, which is also what restores them from a form snapshot.
|
|
286
|
+
- **`ARTIFACT`** binds an `ArtifactAttr` (`{ bucket, objectId, name, mimeType }`). It fetches a thumbnail only for `image/*` types when `showThumbnail !== false`, otherwise shows a MIME-type icon; upload delegates to `ArtifactSelectorComponent`, which also offers **taking a photo or recording a video** with the device camera — shown only where `CameraSupportService` finds one (secure context, `getUserMedia`, a `videoinput` device); the capture then goes through the same name / MIME type / Upload step as a picked file. Delete **actually removes the stored object** (after a confirmation dialog). When the `multiplicity` is multi-valued the value is an `ArtifactAttr[]` (a `null` reads as empty, a lone object saved earlier as one entry): one row per artifact, an upload **appends** instead of replacing, delete removes only that row's artifact, and the selector disappears once the count reaches the upper bound. The list cell then shows one download link per artifact, and the PDF export joins their names. With `isHeading` it degrades to a plain heading. Requires an `ObjectStoreService` provider.
|
|
248
287
|
|
|
249
|
-
These value-editing controls (`ARTIFACT`, `LOOKUP`, `FOREIGN_KEY`, `COMPONENTS`, `TAGS`, `ADDITIONAL_PROPERTIES`) write to their `FormControl` **imperatively** (`setValue` + `markAsDirty`), which is why the form's Save button reacts to `form.events` rather than a plain dirty binding.
|
|
288
|
+
These value-editing controls (`ARTIFACT`, `LOOKUP`, `FOREIGN_KEY`, `RELATED_ENTITIES`, `COMPONENTS`, `TAGS`, `ADDITIONAL_PROPERTIES`) write to their `FormControl` **imperatively** (`setValue` + `markAsDirty`), which is why the form's Save button reacts to `form.events` rather than a plain dirty binding. `EMBEDDED_COMPONENTS` is the exception: its `FormArray` is edited by the sub-forms themselves.
|
|
250
289
|
|
|
251
290
|
> **Note.** `DATE` display/parse format follows Angular Material's ambient date adapter (`MAT_DATE_FORMATS`), configured app-wide rather than per field, so the descriptor's `format` property is not applied here.
|
|
252
291
|
|
|
292
|
+
## Component entities
|
|
293
|
+
|
|
294
|
+
Most entities are aggregate roots — they stand on their own and are reached from their own list. A
|
|
295
|
+
**component** is a part: it belongs to exactly one parent, is created from the parent's form, and is deleted
|
|
296
|
+
outright rather than merely detached when the user removes it there. Two `BaseEntityDescriptor` options
|
|
297
|
+
declare that:
|
|
298
|
+
|
|
299
|
+
| Option | Type | Meaning |
|
|
300
|
+
| --- | --- | --- |
|
|
301
|
+
| `componentParent` | `string \| string[]` | Entity name(s) that may aggregate this one. A list is allowed because one component *type* can be hosted by several parent types (an `App Widget` sits under `App Region`, `App Page` and `App Widget`) — the 1:N invariant holds per *instance*, not per type. Undefined for a stand-alone entity. |
|
|
302
|
+
| `isEmbedded` | `boolean` | `true` when the payload travels inside the parent's payload — no endpoint and no store of its own, and the parent's save persists it. `false` (default) when the component is persisted on its own and points back at its parent through a `FOREIGN_KEY` attribute. Declaring it without `componentParent` throws. |
|
|
303
|
+
|
|
304
|
+
```typescript
|
|
305
|
+
// Embedded: an App Region has no endpoint; it is a slot inside the App Definition document.
|
|
306
|
+
new BaseEntityDescriptor({ entityName: 'App Region', attrDescriptors, componentParent: 'App Definition', isEmbedded: true });
|
|
307
|
+
|
|
308
|
+
// Not embedded: persisted through its own store, with `testEntityId` as the key back to the parent.
|
|
309
|
+
new BaseEntityDescriptor({ entityName: 'Test Entity Component', attrDescriptors, componentParent: 'Test Entity', isEmbedded: false });
|
|
310
|
+
```
|
|
311
|
+
|
|
312
|
+
The parent points back at the component with a `COMPONENTS` (not embedded) or `EMBEDDED_COMPONENTS` (embedded)
|
|
313
|
+
attribute — see [Association vs. containment](#association-vs-containment) for what the two control types do and
|
|
314
|
+
for the errors thrown when the two declarations disagree.
|
|
315
|
+
|
|
316
|
+
Derived from those two:
|
|
317
|
+
|
|
318
|
+
- **`isComponent()`** / **`isComponentOf(entityName)`** — containment predicates.
|
|
319
|
+
- **`parentReferenceAttrName()`** — the `FOREIGN_KEY` attribute pointing at one of the `componentParent`s,
|
|
320
|
+
found through nested `FlexboxDescriptor`s. `undefined` for a stand-alone entity, and for an embedded
|
|
321
|
+
component, which is located by its position in the parent's payload rather than by a key.
|
|
322
|
+
|
|
323
|
+
> **`componentParent` is not `parentEntity`.** `parentEntity` names the **inheritance** supertype and pairs
|
|
324
|
+
> with `isAbstract`; `componentParent` names the **aggregator**. An entity can legitimately have both.
|
|
325
|
+
|
|
326
|
+
Both properties are serialized by `EntityRegistryComponent`, so a Low-Code designer reading the registry sees
|
|
327
|
+
the containment graph alongside the inheritance one.
|
|
328
|
+
|
|
329
|
+
### Registering an embedded component
|
|
330
|
+
|
|
331
|
+
A non-embedded component is a normal entity: it has a service, a store and therefore a facade, and its
|
|
332
|
+
descriptor is resolved through `BASE_ENTITY_FACADE_REGISTRY` like any other. An **embedded** one has nothing to
|
|
333
|
+
put in a facade — no endpoint, no store — yet the parent's form still has to resolve its descriptor to render
|
|
334
|
+
the sub-forms. It is registered instead in `EMBEDDED_ENTITY_DESCRIPTOR_REGISTRY`:
|
|
335
|
+
|
|
336
|
+
```typescript
|
|
337
|
+
{
|
|
338
|
+
provide: EMBEDDED_ENTITY_DESCRIPTOR_REGISTRY,
|
|
339
|
+
useValue: { 'Embedded Component': createEmbeddedComponentDescriptor },
|
|
340
|
+
}
|
|
341
|
+
```
|
|
342
|
+
|
|
343
|
+
- The values are **factories** (`() => BaseEntityDescriptor`), not instances, because a containment graph may be
|
|
344
|
+
cyclic (`App Definition` → `App Region` → `App Widget` → `App Widget`), which eager values cannot express.
|
|
345
|
+
`BaseEntityDescriptorRegistry` memoizes what a factory returns, so the descriptor's identity is stable across
|
|
346
|
+
renders.
|
|
347
|
+
- `BaseEntityDescriptorRegistry.getDescriptor()` consults the facade registry **first** and falls back to this
|
|
348
|
+
one; `getStore()` keeps returning `undefined` for an embedded entity.
|
|
349
|
+
- Such an entity needs no route, container component, service or store — only the entity class, its mapper and
|
|
350
|
+
its descriptor. Its i18n scope is loaded on the **parent's** route, since its labels are rendered there.
|
|
351
|
+
- `EntityRegistryComponent` serializes it too, with no `route`, and the generated e2e list/CRUD suites skip
|
|
352
|
+
`isEmbedded` entities because there is no page to visit.
|
|
353
|
+
|
|
253
354
|
## Per-field styling
|
|
254
355
|
|
|
255
356
|
Two descriptor properties give a consumer per-attribute style control, applied via `[ngClass]`:
|
|
@@ -317,7 +418,7 @@ where `<attrName>` is the attribute's `attrName` (a code identifier — no space
|
|
|
317
418
|
### The library's own strings
|
|
318
419
|
|
|
319
420
|
Everything the library renders that is *not* derived from a descriptor — toolbar labels and tooltips, PDF-export
|
|
320
|
-
and RSQL dialogs, and the list/details tab captions — lives in the `base_entity` scope shipped with the package
|
|
421
|
+
and RSQL dialogs, the delete-confirmation dialogs, and the list/details tab captions — lives in the `base_entity` scope shipped with the package
|
|
321
422
|
(`assets/i18n/base_entity/<lang>.json`, copied into your build). Provide it once on the route that hosts the
|
|
322
423
|
entity screens:
|
|
323
424
|
|
|
@@ -377,7 +478,7 @@ The **✎ (`edit_note`)** button in the query field opens the **advanced query e
|
|
|
377
478
|
- **Live linting** — structural validation (paren balance, clause ordering, unterminated strings) plus semantic checks (unknown field, operator not allowed for the field's type). **Apply** stays disabled while the expression is invalid.
|
|
378
479
|
- A **sample query** inserted on <kbd>Tab</kbd> in an empty editor, plus a matching placeholder.
|
|
379
480
|
|
|
380
|
-
Both the autocomplete and the linter are driven by field metadata derived from the entity's descriptor by `DescriptorBackedFieldMetadataProvider`: each `BaseEntityAttrDescriptor` maps to an RSQL field whose type (and therefore its allowed operators) comes from the `FormControlType` — `CHECKBOX`→boolean, `DATE`→date, `DROPDOWN`/`RADIO`→enum (enum values taken from the attribute's selectables), a numeric/date `TEXT_BOX` input type→number/date, everything else→string. Presentation-only controls (`ARTIFACT`, `
|
|
481
|
+
Both the autocomplete and the linter are driven by field metadata derived from the entity's descriptor by `DescriptorBackedFieldMetadataProvider`: each `BaseEntityAttrDescriptor` maps to an RSQL field whose type (and therefore its allowed operators) comes from the `FormControlType` — `CHECKBOX`→boolean, `DATE`→date, `DROPDOWN`/`RADIO`→enum (enum values taken from the attribute's selectables), a numeric/date `TEXT_BOX` input type→number/date, everything else→string. Presentation-only controls (`ARTIFACT`, `FLEX_BOX`, `LABEL`, `RELATED_ENTITIES`, `TITLE`) are excluded from the searchable fields.
|
|
381
482
|
|
|
382
483
|
To use the editor outside the entity toolbar, provide your own `RsqlFieldMetadataProvider` and bind `RsqlQueryEditorComponent` through a reactive `FormControl` (see `query-editor/example-usage.ts`).
|
|
383
484
|
|
|
@@ -1,10 +1,107 @@
|
|
|
1
1
|
{
|
|
2
|
+
"entity_attribute": {
|
|
3
|
+
"_self": "Attribut",
|
|
4
|
+
"code": "Code",
|
|
5
|
+
"name": "Name",
|
|
6
|
+
"valueKind": "Wertart",
|
|
7
|
+
"formControlType": "Steuerelementtyp",
|
|
8
|
+
"displayOrder": "Anzeigereihenfolge",
|
|
9
|
+
"required": "Erforderlich",
|
|
10
|
+
"multiplicity": "Multiplizität",
|
|
11
|
+
"maxOccurs": "Max. Anzahl",
|
|
12
|
+
"indexed": "Indiziert",
|
|
13
|
+
"isLinkToDetails": "Benennt den Datensatz",
|
|
14
|
+
"autosizeColumn": "Passt die Listenspalte an",
|
|
15
|
+
"linkedEntityType": "Verknüpfte Entität",
|
|
16
|
+
"defaultValue": "Standardwert",
|
|
17
|
+
"enumValues": "Aufzählungswerte",
|
|
18
|
+
"dateStyle": "Datumsstil",
|
|
19
|
+
"timeStyle": "Zeitstil",
|
|
20
|
+
"defaultAvatar": "Standard-Avatar",
|
|
21
|
+
"showMap": "Zeigt eine Karte",
|
|
22
|
+
"mapProvider": "Kartenanbieter",
|
|
23
|
+
"defaultCountry": "Standardland",
|
|
24
|
+
"_tooltips": {
|
|
25
|
+
"code": "Schlüssel, unter dem der Wert gespeichert wird, eindeutig innerhalb des Entitätstyps, z. B. orderNumber. Nicht mehr ändern, sobald Datensätze existieren.",
|
|
26
|
+
"name": "Die Beschriftung des Feldes, wie Benutzer sie in Formularen und Listenspalten sehen, z. B. Bestellnummer.",
|
|
27
|
+
"valueKind": "Welche Art von Wert das Feld enthält: Text, Zahl, Ja/Nein, Datum, Datum und Uhrzeit, eine Auswahl aus einer Liste (ENUM) oder einen Verweis auf einen anderen Datensatz. Bestimmt, wie Werte geprüft und verglichen werden.",
|
|
28
|
+
"formControlType": "Mit welchem Eingabeelement Benutzer das Feld ausfüllen, z. B. TEXT_BOX, TEXTAREA, DROPDOWN oder CHECKBOX. Wählen Sie eines, das zur Wertart passt.",
|
|
29
|
+
"displayOrder": "Position des Feldes im Formular und seiner Spalte in der Liste; kleinere Zahlen kommen zuerst, z. B. 10, 20, 30.",
|
|
30
|
+
"multiplicity": "Wie viele Werte das Feld aufnimmt: 0..1 höchstens einen, 0..n / 1..n beliebig viele (mit 1.. mindestens einen), 0..x / 1..x bis zu Max. Anzahl. Leer lassen für einen einzelnen Wert.",
|
|
31
|
+
"maxOccurs": "Obergrenze für die Anzahl der Werte, z. B. 5. Gilt nur für die Multiplizitäten 0..x und 1..x.",
|
|
32
|
+
"required": "Ob Benutzer das Feld ausfüllen müssen, bevor sie den Datensatz speichern können.",
|
|
33
|
+
"indexed": "Ankreuzen für Felder, nach denen oft gesucht oder gefiltert wird, z. B. eine Kundennummer; das macht solche Abfragen schnell.",
|
|
34
|
+
"isLinkToDetails": "Ankreuzen für das Feld, das den Datensatz benennt, z. B. die Bestellnummer: Es öffnet den Datensatz aus der Liste und steht als Überschrift im Formular. Höchstens ein Feld pro Entitätstyp.",
|
|
35
|
+
"autosizeColumn": "Ankreuzen, damit die Listenspalte des Feldes nur so breit wie ihr Inhalt ist, z. B. bei kurzen Codes oder Kennzeichen.",
|
|
36
|
+
"enumValues": "Für die Wertart ENUM: die Optionen, aus denen Benutzer wählen, je ein Chip, z. B. NEW, PAID, SHIPPED.",
|
|
37
|
+
"linkedEntityType": "Für Verweisfelder (FOREIGN_KEY) und eingebettete Zeilen (EMBEDDED_COMPONENTS): der Code des Entitätstyps, auf den sie zeigen, z. B. customer.",
|
|
38
|
+
"defaultValue": "Wert, der in neuen Datensätzen vorausgefüllt ist, z. B. NEW oder 1. Leer lassen für keinen.",
|
|
39
|
+
"defaultAvatar": "Für AVATAR-Steuerelemente: Icon-Name (z. B. person, sailing) oder Bild-URL, die vor dem Hochladen eines Bildes angezeigt wird.",
|
|
40
|
+
"showMap": "Für ADDRESS-Steuerelemente: die Adresse auf einer Karte zeigen, mit daraus ermittelten Koordinaten.",
|
|
41
|
+
"mapProvider": "Für ADDRESS-Steuerelemente mit Karte: wer sie zeichnet. Leer bedeutet OpenStreetMap; ein Klick öffnet immer Google Maps.",
|
|
42
|
+
"defaultCountry": "Für ADDRESS-Steuerelemente: der ISO-Ländercode, mit dem eine neue Adresse beginnt, z. B. DE. Leer nimmt das Land des Browsers.",
|
|
43
|
+
"dateStyle": "Für DATE- und DATE_TIME-Felder: wie das Datum angezeigt wird, von short (31.12.26) bis full (Donnerstag, 31. Dezember 2026). Leer bedeutet Standard.",
|
|
44
|
+
"timeStyle": "Für DATE_TIME-Felder: wie die Uhrzeit angezeigt wird, von short (14:30) bis long (mit Sekunden und Zeitzone). Leer bedeutet Standard."
|
|
45
|
+
}
|
|
46
|
+
},
|
|
47
|
+
"entity_definition": {
|
|
48
|
+
"_self": "Entitätsdefinition",
|
|
49
|
+
"code": "Code",
|
|
50
|
+
"name": "Name",
|
|
51
|
+
"description": "Beschreibung",
|
|
52
|
+
"status": "Status",
|
|
53
|
+
"isEmbedded": "Eingebettet",
|
|
54
|
+
"componentParents": "Übergeordnete Komponenten",
|
|
55
|
+
"attributes": "Attribute",
|
|
56
|
+
"version": "Version",
|
|
57
|
+
"updatedAt": "Aktualisiert am",
|
|
58
|
+
"releaseState": "Release-Stand",
|
|
59
|
+
"_tooltips": {
|
|
60
|
+
"code": "Eindeutiger Schlüssel des Entitätstyps in Ihrer Organisation, wird in Adressen verwendet. Kurz, kleingeschrieben und URL-tauglich, z. B. order; später möglichst nicht ändern.",
|
|
61
|
+
"name": "Der Entitätsname, unter dem Seiten, Routen und Menüs der Anwendung diesen Typ ansprechen, z. B. Order.",
|
|
62
|
+
"description": "Eine Notiz für Sie und Ihre Mitgestalter, wozu dieser Entitätstyp dient; Benutzer sehen sie nicht.",
|
|
63
|
+
"status": "ACTIVE für einen Typ in Gebrauch, DEPRECATED, um ihn auszumustern: Die Anwendung zeigt einen ausgemusterten Typ nicht mehr an. Ob die Anwendung den Typ überhaupt kennt, entscheidet seine Veröffentlichung, angezeigt unter Release-Stand.",
|
|
64
|
+
"isEmbedded": "Ankreuzen, wenn Datensätze dieses Typs nur innerhalb eines anderen Datensatzes existieren, z. B. Bestellpositionen in einer Bestellung. Dann auch den übergeordneten Typ unter Übergeordnete Komponenten angeben.",
|
|
65
|
+
"componentParents": "Für einen eingebetteten Typ: die Codes der Entitätstypen, deren Datensätze ihn enthalten, z. B. order. Pflicht, wenn Eingebettet angekreuzt ist.",
|
|
66
|
+
"attributes": "Die Felder des Entitätstyps, eine Zeile pro Feld. Sie werden zusammen mit der Definition gespeichert.",
|
|
67
|
+
"version": "Erhöht sich bei jedem Speichern. Wird vom System gesetzt.",
|
|
68
|
+
"updatedAt": "Wann die Definition zuletzt gespeichert wurde. Wird vom System gesetzt.",
|
|
69
|
+
"releaseState": "Ob die laufende Anwendung diese Definition so verwendet, wie sie ist: NEW wurde nie veröffentlicht, CHANGED weicht vom Veröffentlichten ab, RELEASED ist das, was die Anwendung verwendet. Veröffentlichen Sie im Bereich Release, um es zu ändern. Wird vom System gesetzt."
|
|
70
|
+
}
|
|
71
|
+
},
|
|
72
|
+
"artifact": {
|
|
73
|
+
"upload_failure": "Hochladen des Artefakts fehlgeschlagen. Bitte erneut versuchen.",
|
|
74
|
+
"invalid_file_type": "Nur Bilddateien sind erlaubt.",
|
|
75
|
+
"camera_capture": "Foto oder Video aufnehmen"
|
|
76
|
+
},
|
|
77
|
+
"camera_capture": {
|
|
78
|
+
"title": "Kamera",
|
|
79
|
+
"mode": "Aufnahmemodus",
|
|
80
|
+
"photo": "Foto",
|
|
81
|
+
"video": "Video",
|
|
82
|
+
"take_photo": "Foto aufnehmen",
|
|
83
|
+
"start_recording": "Aufnahme starten",
|
|
84
|
+
"stop_recording": "Aufnahme beenden",
|
|
85
|
+
"retake": "Wiederholen",
|
|
86
|
+
"use": "Übernehmen",
|
|
87
|
+
"cancel": "Abbrechen",
|
|
88
|
+
"unavailable": "Die Kamera konnte nicht gestartet werden. Prüfen Sie, ob der Kamerazugriff für diese Seite erlaubt ist."
|
|
89
|
+
},
|
|
2
90
|
"delete_artifact_confirmation_dialog": {
|
|
3
91
|
"title": "Artefakt löschen?",
|
|
4
92
|
"content": "Dadurch wird „{{ artifactName }}\" dauerhaft aus dem Objektspeicher gelöscht.",
|
|
5
93
|
"cancel_button": "Abbrechen",
|
|
6
94
|
"delete_button": "Löschen"
|
|
7
95
|
},
|
|
96
|
+
"delete_component_confirmation_dialog": {
|
|
97
|
+
"title": "Komponente löschen?",
|
|
98
|
+
"content": "Dadurch wird „{{ componentName }}\" dauerhaft gelöscht – eine Komponente gehört ausschließlich zu diesem Datensatz.",
|
|
99
|
+
"cancel_button": "Abbrechen",
|
|
100
|
+
"delete_button": "Löschen"
|
|
101
|
+
},
|
|
102
|
+
"statusbar": {
|
|
103
|
+
"breadcrumb_label": "Datensatz-Hierarchie"
|
|
104
|
+
},
|
|
8
105
|
"tabs": {
|
|
9
106
|
"list": "{{ entity }} - Liste",
|
|
10
107
|
"details": "{{ entity }} - Details"
|
|
@@ -16,7 +113,9 @@
|
|
|
16
113
|
"filter_tooltip": "Geladene Zeilen nach Text filtern",
|
|
17
114
|
"edit_tooltip": "Ausgewählten Datensatz bearbeiten",
|
|
18
115
|
"new_tooltip": "Neuen Datensatz erstellen",
|
|
19
|
-
"delete_tooltip": "Ausgewählte Datensätze löschen"
|
|
116
|
+
"delete_tooltip": "Ausgewählte Datensätze löschen",
|
|
117
|
+
"export_menu": "Exportieren",
|
|
118
|
+
"actions_menu": "Aktion wählen"
|
|
20
119
|
},
|
|
21
120
|
"pdf_export": {
|
|
22
121
|
"button": "PDF",
|
|
@@ -37,5 +136,71 @@
|
|
|
37
136
|
"title": "Erweiterter Abfrage-Editor",
|
|
38
137
|
"cancel_button": "Abbrechen",
|
|
39
138
|
"apply_button": "Übernehmen"
|
|
139
|
+
},
|
|
140
|
+
"embedded_components": {
|
|
141
|
+
"save_owner_first": "Speichern Sie diesen Datensatz, bevor Sie {{ entity }} hinzufügen — eine eingebettete Komponente wird darin gespeichert.",
|
|
142
|
+
"move_up": "Nach oben",
|
|
143
|
+
"move_down": "Nach unten"
|
|
144
|
+
},
|
|
145
|
+
"rich_text": {
|
|
146
|
+
"toolbar": {
|
|
147
|
+
"label": "Textformatierung",
|
|
148
|
+
"bold": "Fett",
|
|
149
|
+
"italic": "Kursiv",
|
|
150
|
+
"strike": "Durchgestrichen",
|
|
151
|
+
"code": "Inline-Code",
|
|
152
|
+
"heading_1": "Überschrift 1",
|
|
153
|
+
"heading_2": "Überschrift 2",
|
|
154
|
+
"heading_3": "Überschrift 3",
|
|
155
|
+
"bullet_list": "Aufzählung",
|
|
156
|
+
"ordered_list": "Nummerierte Liste",
|
|
157
|
+
"blockquote": "Zitat",
|
|
158
|
+
"horizontal_rule": "Trennlinie",
|
|
159
|
+
"undo": "Rückgängig",
|
|
160
|
+
"redo": "Wiederherstellen"
|
|
161
|
+
}
|
|
162
|
+
},
|
|
163
|
+
"comments": {
|
|
164
|
+
"title": "Kommentare",
|
|
165
|
+
"new_placeholder": "Kommentar schreiben…",
|
|
166
|
+
"unknown_author": "Unbekannt",
|
|
167
|
+
"count": "{{ count }} Kommentare"
|
|
168
|
+
},
|
|
169
|
+
"address": {
|
|
170
|
+
"country": "Land",
|
|
171
|
+
"street": "Straße und Hausnummer",
|
|
172
|
+
"address_line2": "Adresszusatz",
|
|
173
|
+
"postal_code": "Postleitzahl",
|
|
174
|
+
"zip_code": "ZIP-Code",
|
|
175
|
+
"postcode": "Postcode",
|
|
176
|
+
"city": "Ort",
|
|
177
|
+
"town": "Ort",
|
|
178
|
+
"region": "Region",
|
|
179
|
+
"state": "Bundesstaat",
|
|
180
|
+
"province": "Provinz",
|
|
181
|
+
"county": "County",
|
|
182
|
+
"prefecture": "Präfektur",
|
|
183
|
+
"canton": "Kanton",
|
|
184
|
+
"latitude": "Breitengrad",
|
|
185
|
+
"longitude": "Längengrad",
|
|
186
|
+
"locate": "Aus der Adresse ermitteln",
|
|
187
|
+
"not_found": "Die Adresse wurde auf der Karte nicht gefunden.",
|
|
188
|
+
"no_location": "Noch kein Standort — Adresse oder Koordinaten eingeben.",
|
|
189
|
+
"map": "Karte der Adresse",
|
|
190
|
+
"open_in_google_maps": "In Google Maps öffnen"
|
|
191
|
+
},
|
|
192
|
+
"geo_location": {
|
|
193
|
+
"capture": "Meinen Standort erfassen",
|
|
194
|
+
"recapture": "Standort erneut erfassen",
|
|
195
|
+
"none": "Noch kein Standort erfasst.",
|
|
196
|
+
"captured_at": "Erfasst {{ time }}",
|
|
197
|
+
"unavailable": "Dieser Browser kann Ihren Standort nicht ermitteln, oder Sie haben es dieser Website nicht erlaubt.",
|
|
198
|
+
"open_in_google_maps": "In Google Maps öffnen",
|
|
199
|
+
"error": {
|
|
200
|
+
"PERMISSION_DENIED": "Der Standortzugriff wurde verweigert. Erlauben Sie ihn in den Website-Einstellungen des Browsers.",
|
|
201
|
+
"POSITION_UNAVAILABLE": "Das Gerät konnte seinen Standort nicht bestimmen.",
|
|
202
|
+
"TIMEOUT": "Die Standortermittlung hat zu lange gedauert. Bitte erneut versuchen.",
|
|
203
|
+
"UNAVAILABLE": "Dieser Browser kann Ihren Standort nicht ermitteln."
|
|
204
|
+
}
|
|
40
205
|
}
|
|
41
206
|
}
|
|
@@ -1,10 +1,107 @@
|
|
|
1
1
|
{
|
|
2
|
+
"entity_attribute": {
|
|
3
|
+
"_self": "Attribute",
|
|
4
|
+
"code": "Code",
|
|
5
|
+
"name": "Name",
|
|
6
|
+
"valueKind": "Value Kind",
|
|
7
|
+
"formControlType": "Control Type",
|
|
8
|
+
"displayOrder": "Display Order",
|
|
9
|
+
"required": "Required",
|
|
10
|
+
"multiplicity": "Multiplicity",
|
|
11
|
+
"maxOccurs": "Max occurs",
|
|
12
|
+
"indexed": "Indexed",
|
|
13
|
+
"isLinkToDetails": "Titles the record",
|
|
14
|
+
"autosizeColumn": "Hugs its list column",
|
|
15
|
+
"linkedEntityType": "Linked Entity",
|
|
16
|
+
"defaultValue": "Default Value",
|
|
17
|
+
"enumValues": "Enum Values",
|
|
18
|
+
"dateStyle": "Date Style",
|
|
19
|
+
"timeStyle": "Time Style",
|
|
20
|
+
"defaultAvatar": "Default Avatar",
|
|
21
|
+
"showMap": "Shows a map",
|
|
22
|
+
"mapProvider": "Map provider",
|
|
23
|
+
"defaultCountry": "Default country",
|
|
24
|
+
"_tooltips": {
|
|
25
|
+
"code": "Key the value is stored under, unique within the entity type, e.g. orderNumber. Avoid changing it once records exist.",
|
|
26
|
+
"name": "The field's label as users see it on forms and list columns, e.g. Order number.",
|
|
27
|
+
"valueKind": "What kind of value the field holds: text, number, yes/no, date, date and time, a choice from a list (ENUM) or a reference to another record. Decides how values are checked and compared.",
|
|
28
|
+
"formControlType": "Which input users fill the field in with, e.g. TEXT_BOX, TEXTAREA, DROPDOWN or CHECKBOX. Pick one that suits the value kind.",
|
|
29
|
+
"displayOrder": "Position of the field on the form and of its column in the list; lower numbers come first, e.g. 10, 20, 30.",
|
|
30
|
+
"multiplicity": "How many values the field takes: 0..1 at most one, 0..n / 1..n any number (at least one with 1..), 0..x / 1..x up to Max occurs. Leave empty for a single value.",
|
|
31
|
+
"maxOccurs": "Upper limit on the number of values, e.g. 5. Only used with the multiplicities 0..x and 1..x.",
|
|
32
|
+
"required": "Whether users must fill the field in before they can save the record.",
|
|
33
|
+
"indexed": "Tick for fields users often search or filter on, e.g. a customer number; it makes those queries fast.",
|
|
34
|
+
"isLinkToDetails": "Tick for the field that names the record, e.g. the order number: it opens the record from the list and heads its form. At most one field per entity type.",
|
|
35
|
+
"autosizeColumn": "Tick to make the field's list column only as wide as its content, e.g. for short codes or flags.",
|
|
36
|
+
"enumValues": "For the ENUM value kind: the options users choose from, one chip each, e.g. NEW, PAID, SHIPPED.",
|
|
37
|
+
"linkedEntityType": "For reference fields (FOREIGN_KEY) and embedded rows (EMBEDDED_COMPONENTS): the code of the entity type they point at, e.g. customer.",
|
|
38
|
+
"defaultValue": "Value pre-filled in new records, e.g. NEW or 1. Leave empty for none.",
|
|
39
|
+
"defaultAvatar": "For AVATAR controls: icon name (e.g. person, sailing) or image URL to show before an image is uploaded.",
|
|
40
|
+
"showMap": "For ADDRESS controls: show the address on a map, with coordinates derived from it.",
|
|
41
|
+
"mapProvider": "For ADDRESS controls with a map: who draws it. Empty uses OpenStreetMap; a click always opens Google Maps.",
|
|
42
|
+
"defaultCountry": "For ADDRESS controls: the ISO country code a new address starts with, e.g. HU. Empty uses the browser's country.",
|
|
43
|
+
"dateStyle": "For DATE and DATE_TIME fields: how the date is shown, from short (12/31/26) to full (Thursday, December 31, 2026). Empty uses the default.",
|
|
44
|
+
"timeStyle": "For DATE_TIME fields: how the time is shown, from short (14:30) to long (with seconds and time zone). Empty uses the default."
|
|
45
|
+
}
|
|
46
|
+
},
|
|
47
|
+
"entity_definition": {
|
|
48
|
+
"_self": "Entity Definition",
|
|
49
|
+
"code": "Code",
|
|
50
|
+
"name": "Name",
|
|
51
|
+
"description": "Description",
|
|
52
|
+
"status": "Status",
|
|
53
|
+
"isEmbedded": "Embedded",
|
|
54
|
+
"componentParents": "Component Parents",
|
|
55
|
+
"attributes": "Attributes",
|
|
56
|
+
"version": "Version",
|
|
57
|
+
"updatedAt": "Updated At",
|
|
58
|
+
"releaseState": "Release",
|
|
59
|
+
"_tooltips": {
|
|
60
|
+
"code": "Unique key of the entity type within your organization, used in addresses. Short, lower-case and URL-safe, e.g. order; avoid changing it later.",
|
|
61
|
+
"name": "The entity name the application's pages, routes and menus refer to this type by, e.g. Order.",
|
|
62
|
+
"description": "A note for you and your fellow designers about what this entity type is for; users do not see it.",
|
|
63
|
+
"status": "ACTIVE for a type in use, DEPRECATED to retire it: the application no longer shows a deprecated type. Whether the application has the type at all is its release, shown under Release.",
|
|
64
|
+
"isEmbedded": "Tick when records of this type exist only inside another record, e.g. order lines inside an order. Then also name the parent under Component Parents.",
|
|
65
|
+
"componentParents": "For an embedded type: the codes of the entity types whose records contain it, e.g. order. Required when Embedded is ticked.",
|
|
66
|
+
"attributes": "The fields of the entity type, one row per field. They are saved together with the definition.",
|
|
67
|
+
"version": "Increases with every save. Set by the system.",
|
|
68
|
+
"updatedAt": "When the definition was last saved. Set by the system.",
|
|
69
|
+
"releaseState": "Whether the running application uses this definition as it stands: NEW was never published, CHANGED differs from what was published, RELEASED is what the application uses. Publish in the Release section to change it. Set by the system."
|
|
70
|
+
}
|
|
71
|
+
},
|
|
72
|
+
"artifact": {
|
|
73
|
+
"upload_failure": "Artifact upload failed. Please try again.",
|
|
74
|
+
"invalid_file_type": "Only image files are allowed.",
|
|
75
|
+
"camera_capture": "Take photo or video"
|
|
76
|
+
},
|
|
77
|
+
"camera_capture": {
|
|
78
|
+
"title": "Camera",
|
|
79
|
+
"mode": "Capture mode",
|
|
80
|
+
"photo": "Photo",
|
|
81
|
+
"video": "Video",
|
|
82
|
+
"take_photo": "Take photo",
|
|
83
|
+
"start_recording": "Start recording",
|
|
84
|
+
"stop_recording": "Stop recording",
|
|
85
|
+
"retake": "Retake",
|
|
86
|
+
"use": "Use",
|
|
87
|
+
"cancel": "Cancel",
|
|
88
|
+
"unavailable": "The camera could not be started. Check that camera access is allowed for this site."
|
|
89
|
+
},
|
|
2
90
|
"delete_artifact_confirmation_dialog": {
|
|
3
91
|
"title": "Delete artifact?",
|
|
4
92
|
"content": "This will permanently delete \"{{ artifactName }}\" from the object store.",
|
|
5
93
|
"cancel_button": "Cancel",
|
|
6
94
|
"delete_button": "Delete"
|
|
7
95
|
},
|
|
96
|
+
"delete_component_confirmation_dialog": {
|
|
97
|
+
"title": "Delete component?",
|
|
98
|
+
"content": "This will permanently delete \"{{ componentName }}\" — a component belongs to this record only.",
|
|
99
|
+
"cancel_button": "Cancel",
|
|
100
|
+
"delete_button": "Delete"
|
|
101
|
+
},
|
|
102
|
+
"statusbar": {
|
|
103
|
+
"breadcrumb_label": "Record hierarchy"
|
|
104
|
+
},
|
|
8
105
|
"tabs": {
|
|
9
106
|
"list": "{{ entity }} - list",
|
|
10
107
|
"details": "{{ entity }} - details"
|
|
@@ -16,7 +113,9 @@
|
|
|
16
113
|
"filter_tooltip": "Filter the loaded rows by text",
|
|
17
114
|
"edit_tooltip": "Edit the selected record",
|
|
18
115
|
"new_tooltip": "Create a new record",
|
|
19
|
-
"delete_tooltip": "Delete the selected records"
|
|
116
|
+
"delete_tooltip": "Delete the selected records",
|
|
117
|
+
"export_menu": "Export",
|
|
118
|
+
"actions_menu": "Choose action"
|
|
20
119
|
},
|
|
21
120
|
"pdf_export": {
|
|
22
121
|
"button": "PDF",
|
|
@@ -37,5 +136,71 @@
|
|
|
37
136
|
"title": "Advanced query editor",
|
|
38
137
|
"cancel_button": "Cancel",
|
|
39
138
|
"apply_button": "Apply"
|
|
139
|
+
},
|
|
140
|
+
"embedded_components": {
|
|
141
|
+
"save_owner_first": "Save this record before adding {{ entity }} — an embedded component is stored inside it.",
|
|
142
|
+
"move_up": "Move up",
|
|
143
|
+
"move_down": "Move down"
|
|
144
|
+
},
|
|
145
|
+
"rich_text": {
|
|
146
|
+
"toolbar": {
|
|
147
|
+
"label": "Text formatting",
|
|
148
|
+
"bold": "Bold",
|
|
149
|
+
"italic": "Italic",
|
|
150
|
+
"strike": "Strikethrough",
|
|
151
|
+
"code": "Inline code",
|
|
152
|
+
"heading_1": "Heading 1",
|
|
153
|
+
"heading_2": "Heading 2",
|
|
154
|
+
"heading_3": "Heading 3",
|
|
155
|
+
"bullet_list": "Bullet list",
|
|
156
|
+
"ordered_list": "Numbered list",
|
|
157
|
+
"blockquote": "Quote",
|
|
158
|
+
"horizontal_rule": "Divider",
|
|
159
|
+
"undo": "Undo",
|
|
160
|
+
"redo": "Redo"
|
|
161
|
+
}
|
|
162
|
+
},
|
|
163
|
+
"comments": {
|
|
164
|
+
"title": "Comments",
|
|
165
|
+
"new_placeholder": "Write a comment…",
|
|
166
|
+
"unknown_author": "Unknown",
|
|
167
|
+
"count": "{{ count }} comments"
|
|
168
|
+
},
|
|
169
|
+
"address": {
|
|
170
|
+
"country": "Country",
|
|
171
|
+
"street": "Street and number",
|
|
172
|
+
"address_line2": "Address line 2",
|
|
173
|
+
"postal_code": "Postal code",
|
|
174
|
+
"zip_code": "ZIP code",
|
|
175
|
+
"postcode": "Postcode",
|
|
176
|
+
"city": "City",
|
|
177
|
+
"town": "Town",
|
|
178
|
+
"region": "Region",
|
|
179
|
+
"state": "State",
|
|
180
|
+
"province": "Province",
|
|
181
|
+
"county": "County",
|
|
182
|
+
"prefecture": "Prefecture",
|
|
183
|
+
"canton": "Canton",
|
|
184
|
+
"latitude": "Latitude",
|
|
185
|
+
"longitude": "Longitude",
|
|
186
|
+
"locate": "Locate from the address",
|
|
187
|
+
"not_found": "The address could not be found on the map.",
|
|
188
|
+
"no_location": "No location yet — fill in the address or the coordinates.",
|
|
189
|
+
"map": "Map of the address",
|
|
190
|
+
"open_in_google_maps": "Open in Google Maps"
|
|
191
|
+
},
|
|
192
|
+
"geo_location": {
|
|
193
|
+
"capture": "Record my location",
|
|
194
|
+
"recapture": "Record my location again",
|
|
195
|
+
"none": "No location recorded yet.",
|
|
196
|
+
"captured_at": "Recorded {{ time }}",
|
|
197
|
+
"unavailable": "This browser cannot tell your location, or you have not allowed this site to read it.",
|
|
198
|
+
"open_in_google_maps": "Open in Google Maps",
|
|
199
|
+
"error": {
|
|
200
|
+
"PERMISSION_DENIED": "Location access was refused. Allow it in the browser's site settings to record a location.",
|
|
201
|
+
"POSITION_UNAVAILABLE": "The device could not determine its location.",
|
|
202
|
+
"TIMEOUT": "Reading the location took too long. Try again.",
|
|
203
|
+
"UNAVAILABLE": "This browser cannot tell your location."
|
|
204
|
+
}
|
|
40
205
|
}
|
|
41
206
|
}
|