With this commit we can add, delete, move and rotate elements

jurra · jurra · commit b73c02f3a6b6 · 2025-01-09T10:24:58.000+01:00
diff --git a/src/application/ElementService.js b/src/application/ElementService.js
@@ -0,0 +1,91 @@
+import { Position } from '../domain/valueObjects/Position.js';
+import { Element } from '../domain/entities/Element.js';
+
+export class ElementService {
+    /**
+     * Creates a new element.
+     * 
+     * @param {Function} ElementClass - The class of the element to create (e.g., Resistor, Junction).
+     * @param {string} id - The unique identifier for the element.
+     * @param {Position[]} terminals - The terminal positions.
+     * @param {Object} propertiesArgs - The arguments for the specific properties container.
+     * @returns {Element} The newly created element.
+     */
+    static createElement(ElementClass, id, terminals, propertiesArgs) {
+        return new ElementClass(id, terminals, ...propertiesArgs);
+    }
+
+    /**
+     * Deletes an element.
+     * 
+     * @param {Element[]} elements - The array of elements.
+     * @param {string} id - The unique identifier of the element to delete.
+     * @returns {Element[]} The updated list of elements.
+     */
+    static deleteElement(elements, id) {
+        return elements.filter(element => element.id !== id);
+    }
+
+    /**
+     * Moves an element to a new position, updating all terminal positions.
+     * 
+     * @param {Element} element - The element to move.
+     * @param {Position} newReferencePosition - The new position for the reference terminal.
+     */
+    static moveElement(element, newReferencePosition) {
+        const refTerminal = element.terminals[0]; // Reference terminal
+        const deltaX = newReferencePosition.x - refTerminal.x;
+        const deltaY = newReferencePosition.y - refTerminal.y;
+
+        element.terminals = element.terminals.map(terminal => 
+            new Position(terminal.x + deltaX, terminal.y + deltaY)
+        );
+    }
+
+    /**
+     * Rotates an element to a new orientation.
+     * 
+     * @param {Element} element - The element to rotate.
+     * @param {number} newOrientation - The new orientation (0, 90, 180, or 270 degrees).
+     */
+    static rotateElement(element, newOrientation) {
+        if (![0, 90, 180, 270].includes(newOrientation)) {
+            throw new Error("Orientation must be one of 0, 90, 180, or 270 degrees.");
+        }
+
+        const refTerminal = element.terminals[0]; // Reference terminal
+        const refX = refTerminal.x;
+        const refY = refTerminal.y;
+
+        element.terminals = element.terminals.map((terminal, index) => {
+            if (index === 0) return terminal; // Keep the reference terminal unchanged
+
+            // Calculate relative position
+            const relX = terminal.x - refX;
+            const relY = terminal.y - refY;
+
+            // Rotate relative position
+            const [newRelX, newRelY] = ElementService._rotatePosition(relX, relY, newOrientation);
+
+            // Return the new absolute position
+            return new Position(refX + newRelX, refY + newRelY);
+        });
+    }
+
+    /**
+     * Rotates a position around the origin.
+     * 
+     * @param {number} x - The x-coordinate of the position.
+     * @param {number} y - The y-coordinate of the position.
+     * @param {number} angle - The angle to rotate by (in degrees).
+     * @returns {number[]} The rotated [x, y] position.
+     */
+    static _rotatePosition(x, y, angle) {
+        const radians = (Math.PI / 180) * angle;
+        const cos = Math.cos(radians);
+        const sin = Math.sin(radians);
+        const newX = Math.round(x * cos - y * sin);
+        const newY = Math.round(x * sin + y * cos);
+        return [newX, newY];
+    }
+}
diff --git a/tests/domain/Element.test.js b/tests/domain/Element.test.js
@@ -4,7 +4,6 @@ import { Position } from '../../src/domain/valueObjects/Position.js';
 import { Label } from '../../src/domain/valueObjects/Label.js';
 import { Properties } from '../../src/domain/valueObjects/Properties.js';
 
-console.log("This test runs successfully")
 
 describe('Basic Import Test', () => {
     it('should import Element successfully', () => {
diff --git a/tests/domain/ElementService.test.js b/tests/domain/ElementService.test.js
@@ -0,0 +1,110 @@
+import { expect } from 'chai';
+import { ElementService } from '../../src/application/ElementService.js';
+import { MockElement } from './MockElement.js'; // A mock element class for testing
+import { Position } from '../../src/domain/valueObjects/Position.js';
+import { Properties } from '../../src/domain/valueObjects/Properties.js';
+import { Label } from '../../src/domain/valueObjects/Label.js';
+
+describe('Element Service Tests', () => {
+    describe('Element Creation', () => {
+        it('should create an element successfully', () => {
+            const terminals = [new Position(10, 20), new Position(30, 40)];
+            const properties = new Properties({ resistance: 100 });
+            const element = ElementService.createElement(MockElement, 'E1', terminals, [null, properties]);
+
+            expect(element).to.be.instanceOf(MockElement);
+            expect(element.id).to.equal('E1');
+            expect(element.terminals).to.deep.equal(terminals);
+            expect(element.properties).to.equal(properties);
+        });
+
+        it('should throw an error if creation inputs are invalid', () => {
+            expect(() => ElementService.createElement(MockElement, 'E2', [10, 20], [null, new Properties()])).to.throw(
+                "Terminals must be an array of Position instances."
+            );
+        });
+    });
+
+    describe('Element Deletion', () => {
+        it('should delete an element successfully', () => {
+            const terminals = [new Position(10, 20)];
+            const properties = new Properties();
+            const element = new MockElement('E3', terminals, null, properties);
+
+            let elements = [element];
+            elements = ElementService.deleteElement(elements, 'E3');
+
+            expect(elements).to.be.an('array').that.is.empty;
+        });
+
+        it('should do nothing when deleting a non-existent element', () => {
+            const terminals = [new Position(10, 20)];
+            const properties = new Properties();
+            const element = new MockElement('E4', terminals, null, properties);
+
+            let elements = [element];
+            elements = ElementService.deleteElement(elements, 'NonExistentID');
+
+            expect(elements).to.have.lengthOf(1);
+            expect(elements[0].id).to.equal('E4');
+        });
+    });
+
+    describe('Element Movement', () => {
+        it('should move an element successfully', () => {
+            const terminals = [new Position(10, 20), new Position(30, 40)];
+            const element = new MockElement('E5', terminals, null, new Properties());
+
+            ElementService.moveElement(element, new Position(20, 30));
+
+            expect(element.terminals).to.deep.equal([
+                new Position(20, 30),
+                new Position(40, 50),
+            ]);
+        });
+
+        it('should not change terminals if moved to the same position', () => {
+            const terminals = [new Position(10, 20), new Position(30, 40)];
+            const element = new MockElement('E6', terminals, null, new Properties());
+
+            ElementService.moveElement(element, new Position(10, 20));
+
+            expect(element.terminals).to.deep.equal(terminals);
+        });
+    });
+
+    describe('Element Rotation', () => {
+        it('should rotate an element by 90 degrees', () => {
+            const terminals = [new Position(10, 10), new Position(20, 10)];
+            const element = new MockElement('E7', terminals, null, new Properties());
+
+            ElementService.rotateElement(element, 90);
+
+            expect(element.terminals).to.deep.equal([
+                new Position(10, 10), // Reference terminal remains unchanged
+                new Position(10, 20), // Rotated position
+            ]);
+        });
+
+        it('should rotate an element by 180 degrees', () => {
+            const terminals = [new Position(10, 10), new Position(20, 10)];
+            const element = new MockElement('E8', terminals, null, new Properties());
+
+            ElementService.rotateElement(element, 180);
+
+            expect(element.terminals).to.deep.equal([
+                new Position(10, 10), // Reference terminal remains unchanged
+                new Position(0, 10), // Rotated position
+            ]);
+        });
+
+        it('should throw an error for invalid rotation angles', () => {
+            const terminals = [new Position(10, 10), new Position(20, 10)];
+            const element = new MockElement('E9', terminals, null, new Properties());
+
+            expect(() => ElementService.rotateElement(element, 45)).to.throw(
+                "Orientation must be one of 0, 90, 180, or 270 degrees."
+            );
+        });
+    });
+});
diff --git a/tests/domain/MockElement.js b/tests/domain/MockElement.js
@@ -0,0 +1,20 @@
+import { Element } from '../../src/domain/entities/Element.js';
+import { Properties } from '../../src/domain/valueObjects/Properties.js';
+
+/**
+ * MockElement class extends the Element class for testing purposes.
+ */
+export class MockElement extends Element {
+    /**
+     * Creates an instance of MockElement.
+     * 
+     * @param {string} id - The unique identifier for the element.
+     * @param {Position[]} terminals - The list of terminal positions.
+     * @param {Label|null} label - The label of the element (optional).
+     * @param {Properties} properties - A container for the element's specific properties.
+     */
+    constructor(id, terminals = [], label = null, properties = new Properties()) {
+        super(id, terminals, label, properties);
+        this.type = 'mock';
+    }
+}
