@itwin/core-backend 5.3.0-dev.6 → 5.3.0-dev.8

package/lib/esm/test/annotations/Fields.test.js

@@ -13,7 +13,7 @@ import { Point3d, YawPitchRollAngles } from "@itwin/core-geometry";
 import { Schema, Schemas } from "../../Schema";
 import { ClassRegistry } from "../../ClassRegistry";
 import { PhysicalElement } from "../../Element";
-import { ElementOwnsUniqueAspect, ElementUniqueAspect, FontFile, TextAnnotation3d } from "../../core-backend";
+import { ElementOwnsUniqueAspect, ElementUniqueAspect, FontFile, IModelElementCloneContext, TextAnnotation3d } from "../../core-backend";
 import { ElementDrivesTextAnnotation, TextAnnotationUsesTextStyleByDefault } from "../../annotations/ElementDrivesTextAnnotation";
 function isIntlSupported() {
     // Node in the mobile add-on does not include Intl, so this test fails. Right now, mobile
@@ -21,6 +21,55 @@ function isIntlSupported() {
     // solution.
     return !ProcessDetector.isMobileAppBackend;
 }
+function createTestElement(imodel, model, category, overrides, aspectProp = 999) {
+    const props = {
+        classFullName: "Fields:TestElement",
+        model,
+        category,
+        code: Code.createEmpty(),
+        intProp: 100,
+        point: { x: 1, y: 2, z: 3 },
+        strings: ["a", "b", `"name": "c"`],
+        datetime: new Date("2025-08-28T13:45:30.123Z"),
+        intEnum: 1,
+        outerStruct: {
+            innerStruct: { bool: false, doubles: [1, 2, 3] },
+            innerStructs: [{ bool: true, doubles: [] }, { bool: false, doubles: [5, 4, 3, 2, 1] }],
+        },
+        outerStructs: [{
+                innerStruct: { bool: true, doubles: [10, 9] },
+                innerStructs: [{ bool: false, doubles: [5] }],
+            }],
+        placement: {
+            origin: new Point3d(1, 2, 0),
+            angles: new YawPitchRollAngles(),
+        },
+        jsonProperties: {
+            stringProp: "abc",
+            ints: [10, 11, 12, 13],
+            bool: true,
+            zoo: {
+                address: {
+                    zipcode: 12345,
+                },
+                birds: [
+                    { name: "duck", sound: "quack" },
+                    { name: "hawk", sound: "scree!" },
+                ],
+            },
+        },
+        ...overrides,
+    };
+    const id = imodel.elements.insertElement(props);
+    const aspectProps = {
+        classFullName: TestAspect.classFullName,
+        aspectProp,
+        element: new ElementOwnsUniqueAspect(id),
+    };
+    imodel.elements.insertAspect(aspectProps);
+    imodel.saveChanges();
+    return id;
+}
 describe("updateField", () => {
     const mockElementId = "0x1";
     const mockPath = {
@@ -103,43 +152,43 @@ describe("updateField", () => {
         expect(fieldRun.cachedContent).to.equal(FieldRun.invalidContentIndicator);
     });
 });
-const fieldsSchemaXml = `
-<?xml version="1.0" encoding="UTF-8"?>
-<ECSchema schemaName="Fields" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
-  <ECSchemaReference name="BisCore" version="01.00.04" alias="bis"/>
-
-  <ECEnumeration typeName="IntEnum" backingTypeName="int">
-    <ECEnumerator name="one" displayLabel="One" value="1" />
-    <ECEnumerator name="two" displayLabel="Two" value="2"/>
-  </ECEnumeration>
-
-  <ECStructClass typeName="InnerStruct" modifier="None">
-    <ECProperty propertyName="bool" typeName="boolean"/>
-    <ECArrayProperty propertyName="doubles" typeName="double" minOccurs="0" maxOccurs="unbounded"/>
-  </ECStructClass>
-
-  <ECStructClass typeName="OuterStruct" modifier="None">
-    <ECStructProperty propertyName="innerStruct" typeName="InnerStruct"/>
-    <ECStructArrayProperty propertyName="innerStructs" typeName="InnerStruct" minOccurs="0" maxOccurs="unbounded"/>
-  </ECStructClass>
-
-  <ECEntityClass typeName="TestElement" modifier="None">
-    <BaseClass>bis:PhysicalElement</BaseClass>
-    <ECProperty propertyName="intProp" typeName="int"/>
-    <ECProperty propertyName="point" typeName="point3d"/>
-    <ECProperty propertyName="maybeNull" typeName="int"/>
-    <ECProperty propertyName="datetime" typeName="dateTime"/>
-    <ECArrayProperty propertyName="strings" typeName="string" minOccurs="0" maxOccurs="unbounded"/>
-    <ECStructProperty propertyName="outerStruct" typeName="OuterStruct"/>
-    <ECStructArrayProperty propertyName="outerStructs" typeName="OuterStruct" minOccurs="0" maxOccurs="unbounded"/>
-    <ECProperty propertyName="intEnum" typeName="IntEnum"/>
-  </ECEntityClass>
-
-  <ECEntityClass typeName="TestAspect" modifier="None">
-    <BaseClass>bis:ElementUniqueAspect</BaseClass>
-    <ECProperty propertyName="aspectProp" typeName="int"/>
-  </ECEntityClass>
-</ECSchema>
+const fieldsSchemaXml = `
+<?xml version="1.0" encoding="UTF-8"?>
+<ECSchema schemaName="Fields" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+  <ECSchemaReference name="BisCore" version="01.00.04" alias="bis"/>
+
+  <ECEnumeration typeName="IntEnum" backingTypeName="int">
+    <ECEnumerator name="one" displayLabel="One" value="1" />
+    <ECEnumerator name="two" displayLabel="Two" value="2"/>
+  </ECEnumeration>
+
+  <ECStructClass typeName="InnerStruct" modifier="None">
+    <ECProperty propertyName="bool" typeName="boolean"/>
+    <ECArrayProperty propertyName="doubles" typeName="double" minOccurs="0" maxOccurs="unbounded"/>
+  </ECStructClass>
+
+  <ECStructClass typeName="OuterStruct" modifier="None">
+    <ECStructProperty propertyName="innerStruct" typeName="InnerStruct"/>
+    <ECStructArrayProperty propertyName="innerStructs" typeName="InnerStruct" minOccurs="0" maxOccurs="unbounded"/>
+  </ECStructClass>
+
+  <ECEntityClass typeName="TestElement" modifier="None">
+    <BaseClass>bis:PhysicalElement</BaseClass>
+    <ECProperty propertyName="intProp" typeName="int"/>
+    <ECProperty propertyName="point" typeName="point3d"/>
+    <ECProperty propertyName="maybeNull" typeName="int"/>
+    <ECProperty propertyName="datetime" typeName="dateTime"/>
+    <ECArrayProperty propertyName="strings" typeName="string" minOccurs="0" maxOccurs="unbounded"/>
+    <ECStructProperty propertyName="outerStruct" typeName="OuterStruct"/>
+    <ECStructArrayProperty propertyName="outerStructs" typeName="OuterStruct" minOccurs="0" maxOccurs="unbounded"/>
+    <ECProperty propertyName="intEnum" typeName="IntEnum"/>
+  </ECEntityClass>
+
+  <ECEntityClass typeName="TestAspect" modifier="None">
+    <BaseClass>bis:ElementUniqueAspect</BaseClass>
+    <ECProperty propertyName="aspectProp" typeName="int"/>
+  </ECEntityClass>
+</ECSchema>
 `;
 class TestElement extends PhysicalElement {
     static get className() { return "TestElement"; }
@@ -178,53 +227,8 @@ describe("Field evaluation", () => {
     after(() => {
         imodel.close();
     });
-    function insertTestElement() {
-        const props = {
-            classFullName: "Fields:TestElement",
-            model,
-            category,
-            code: Code.createEmpty(),
-            intProp: 100,
-            point: { x: 1, y: 2, z: 3 },
-            strings: ["a", "b", `"name": "c"`],
-            datetime: new Date("2025-08-28T13:45:30.123Z"),
-            intEnum: 1,
-            outerStruct: {
-                innerStruct: { bool: false, doubles: [1, 2, 3] },
-                innerStructs: [{ bool: true, doubles: [] }, { bool: false, doubles: [5, 4, 3, 2, 1] }],
-            },
-            outerStructs: [{
-                    innerStruct: { bool: true, doubles: [10, 9] },
-                    innerStructs: [{ bool: false, doubles: [5] }],
-                }],
-            placement: {
-                origin: new Point3d(1, 2, 0),
-                angles: new YawPitchRollAngles(),
-            },
-            jsonProperties: {
-                stringProp: "abc",
-                ints: [10, 11, 12, 13],
-                bool: true,
-                zoo: {
-                    address: {
-                        zipcode: 12345,
-                    },
-                    birds: [
-                        { name: "duck", sound: "quack" },
-                        { name: "hawk", sound: "scree!" },
-                    ],
-                },
-            },
-        };
-        const id = imodel.elements.insertElement(props);
-        const aspectProps = {
-            classFullName: TestAspect.classFullName,
-            aspectProp: 999,
-            element: new ElementOwnsUniqueAspect(id),
-        };
-        imodel.elements.insertAspect(aspectProps);
-        imodel.saveChanges();
-        return id;
+    function insertTestElement(overrides, aspectProp) {
+        return createTestElement(imodel, model, category, overrides, aspectProp);
     }
     function evaluateField(propertyPath, propertyHost, deletedDependency = false) {
         if (typeof propertyHost === "string") {
@@ -406,7 +410,7 @@ describe("Field evaluation", () => {
             expect(fieldRun2.cachedContent).to.equal("a");
         });
     });
-    function insertAnnotationElement(textBlock) {
+    function createAnnotationElement(textBlock) {
         const elem = TextAnnotation3d.fromJSON({
             model,
             category,
@@ -422,6 +426,10 @@ describe("Field evaluation", () => {
             const annotation = TextAnnotation.fromJSON({ textBlock: textBlock.toJSON() });
             elem.setAnnotation(annotation);
         }
+        return elem;
+    }
+    function insertAnnotationElement(textBlock) {
+        const elem = createAnnotationElement(textBlock);
         return elem.insert();
     }
     describe("ElementDrivesTextAnnotation", () => {
@@ -543,8 +551,9 @@ describe("Field evaluation", () => {
                 expectNumRelationships(1, targetId);
             });
         });
-        function expectText(expected, elemId) {
-            const elem = imodel.elements.getElement(elemId);
+        function expectText(expected, elemId, db) {
+            db = db ?? imodel;
+            const elem = db.elements.getElement(elemId);
             const anno = elem.getAnnotation();
             const actual = anno.textBlock.stringify();
             expect(actual).to.equal(expected);
@@ -637,6 +646,92 @@ describe("Field evaluation", () => {
             imodel.saveChanges();
             expectText("12.5", targetId);
         });
+        describe("remapFields", () => {
+            let dstIModel;
+            let dstModel;
+            let dstCategory;
+            let dstSourceElementId;
+            before(async () => {
+                const path = IModelTestUtils.prepareOutputFile("RemapFields", `dst.bim`);
+                dstIModel = StandaloneDb.createEmpty(path, { rootSubject: { name: `RemapFields-dst` }, allowEdit: JSON.stringify({ txns: true }) });
+                await registerTestSchema(dstIModel);
+                // Insert additional unused elements to ensure element Ids differ between src and dst iModels
+                for (let i = 0; i < 3; i++) {
+                    IModelTestUtils.createAndInsertPhysicalPartitionAndModel(dstIModel, Code.createEmpty(), true);
+                }
+                const modelAndElement = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(dstIModel, Code.createEmpty(), true);
+                expect(modelAndElement[0]).to.equal(modelAndElement[1]);
+                dstModel = modelAndElement[1];
+                dstCategory = SpatialCategory.insert(dstIModel, StandaloneDb.dictionaryId, `dstCat`, new SubCategoryAppearance());
+                dstSourceElementId = createTestElement(dstIModel, dstModel, dstCategory, {
+                    intProp: 200,
+                    point: { x: -1, y: -2, z: -3 },
+                    strings: ["x", "y", "z"],
+                    intEnum: 2,
+                }, 1234);
+                await dstIModel.fonts.embedFontFile({
+                    file: FontFile.createFromTrueTypeFileName(IModelTestUtils.resolveFontFile("Karla-Regular.ttf"))
+                });
+                expect(dstCategory).not.to.equal(category);
+                expect(dstModel).not.to.equal(model);
+                expect(dstSourceElementId).not.to.equal(sourceElementId);
+            });
+            after(() => {
+                dstIModel.close();
+            });
+            function getTextBlockJson() {
+                return {
+                    children: [{
+                            children: [{
+                                    type: "field",
+                                    propertyHost: {
+                                        elementId: sourceElementId,
+                                        schemaName: "Fields",
+                                        className: "TestElement",
+                                    },
+                                    propertyPath: { propertyName: "intProp" },
+                                    cachedContent: "intProp",
+                                }, {
+                                    type: "field",
+                                    propertyHost: {
+                                        elementId: category,
+                                        schemaName: "BisCore",
+                                        className: "Element",
+                                    },
+                                    propertyPath: { propertyName: "CodeValue" },
+                                    cachedContent: "CodeValue"
+                                }],
+                        }],
+                };
+            }
+            function expectHostIds(elem, host1, host2) {
+                const anno = elem.getAnnotation();
+                expect(anno.textBlock.children.length).to.equal(1);
+                const para = anno.textBlock.children[0];
+                expect(para.children.length).to.equal(2);
+                expect(para.children.every((x) => x.type === "field"));
+                const field1 = para.children[0];
+                expect(field1.propertyHost.elementId).to.equal(host1);
+                const field2 = para.children[1];
+                expect(field2.propertyHost.elementId).to.equal(host2);
+            }
+            it("remaps field hosts", () => {
+                const elem = createAnnotationElement(TextBlock.create(getTextBlockJson()));
+                expectHostIds(elem, sourceElementId, category);
+                const context = new IModelElementCloneContext(imodel, dstIModel);
+                context.remapElement(sourceElementId, dstSourceElementId);
+                context.remapElement(category, dstCategory);
+                ElementDrivesTextAnnotation.remapFields(elem, context);
+                expectHostIds(elem, dstSourceElementId, dstCategory);
+            });
+            it("invalidates field host if source element not remapped", () => {
+                const elem = createAnnotationElement(TextBlock.create(getTextBlockJson()));
+                expectHostIds(elem, sourceElementId, category);
+                const context = new IModelElementCloneContext(imodel, dstIModel);
+                ElementDrivesTextAnnotation.remapFields(elem, context);
+                expectHostIds(elem, Id64.invalid, Id64.invalid);
+            });
+        });
     });
     describe("Format Validation", () => {
         it("validates formatting options for string property type", () => {