feat: open the last locked fields for editing, keeping their history intact

Four fields were still frozen because changing them would have bypassed the
record that makes the change traceable, and a user's login data could not be
corrected at all. Locking a field is the wrong trade: a wrong value stays in
the system forever. The fix is to let the edit write the same history entry the
dedicated endpoint writes.

- A colony's apiary is editable through PATCH and writes the same
  ColonyApiaryHistory entry POST /colonies/:id/move writes, so the location
  history never skips a stand the colony was recorded on.
- A honey batch's storage container is editable through PATCH and writes the
  same HoneyBatchRelocation entry POST /honey-batches/:id/relocate writes.
- A stock item's quantity is editable and books the difference as an ADJUSTMENT
  movement, so the stored level stays the sum of its movements.
- A role's key is editable (system roles were already rejected outright by
  RolesService.update, which keeps the seed's ADMIN lookup intact).
- A user's e-mail - the login identity - is editable. A typo there previously
  locked the account out for good.
- New POST /users/:id/reset-password lets an administrator set someone else's
  password: there is no self-service reset flow, so a forgotten password was
  the one thing no edit could repair. It revokes every refresh token and clears
  the permission cache exactly as a self-service change does, refuses to act on
  your own account (that goes through /profile/password, which proves ownership
  by asking for the current one), and never writes the password to the log.

Frontend:
- Users had no edit UI at all, although PATCH /users/:id existed. New
  EditUserDialog covers name, e-mail, role and an optional new password.
- Colony, honey batch and stock item forms gained the newly editable fields,
  each with a note saying the correction is recorded as a move, a relocation
  or a stock adjustment.
- The role dialog gained the key field.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

ApiCore-Backend/src/storage/dto/update-stock-item.dto.ts

@@ -1,12 +1,10 @@
-import { PartialType, PickType } from '@nestjs/swagger';
+import { PartialType } from '@nestjs/swagger';
 import { CreateStockItemDto } from './create-stock-item.dto';
 
-export class UpdateStockItemDto extends PartialType(
-  PickType(CreateStockItemDto, [
-    'name',
-    'category',
-    'unit',
-    'minThreshold',
-    'notes',
-  ] as const),
-) {}
+/**
+ * `quantity` is editable here, not only through stock movements: a stock level
+ * typed in wrong has to be correctable directly. The service books the
+ * difference as an ADJUSTMENT movement, so the movement history still adds up
+ * to the stored quantity and nothing is corrected behind its back.
+ */
+export class UpdateStockItemDto extends PartialType(CreateStockItemDto) {}

ApiCore-Backend/src/storage/storage.service.spec.ts

@@ -132,4 +132,28 @@ describe('StorageService', () => {
     ];
     expect(updateArg.data.quantity.increment).toBe(-3);
   });
+
+  it('books the difference as an ADJUSTMENT movement when the stock quantity is corrected', async () => {
+    prisma.stockItem.findUnique.mockResolvedValue(stockItem);
+
+    await service.updateStockItem('item-1', { quantity: 7 }, 'user-1');
+
+    expect(tx.stockMovement.create).toHaveBeenCalledWith({
+      data: {
+        stockItemId: 'item-1',
+        type: 'ADJUSTMENT',
+        quantity: -3,
+        userId: 'user-1',
+        notes: 'Korrektur über Artikel bearbeiten',
+      },
+    });
+  });
+
+  it('books no movement when an edit leaves the stock quantity untouched', async () => {
+    prisma.stockItem.findUnique.mockResolvedValue(stockItem);
+
+    await service.updateStockItem('item-1', { name: 'Futtersirup' }, 'user-1');
+
+    expect(tx.stockMovement.create).not.toHaveBeenCalled();
+  });
 });

ApiCore-Backend/src/storage/storage.service.ts

@@ -106,9 +106,29 @@ export class StorageService {
     actingUserId: string,
   ): Promise<StockItem> {
     const before = await this.findStockItemById(id);
-    const stockItem = await this.prisma.stockItem.update({
-      where: { id },
-      data: { ...dto },
+    const correction =
+      dto.quantity === undefined ? 0 : dto.quantity - before.quantity;
+
+    const stockItem = await this.prisma.$transaction(async (tx) => {
+      const updated = await tx.stockItem.update({
+        where: { id },
+        data: { ...dto },
+      });
+      // Booking the difference keeps the movement history consistent with the
+      // stored quantity - without it, a corrected stock level would no longer
+      // be the sum of its movements.
+      if (correction !== 0) {
+        await tx.stockMovement.create({
+          data: {
+            stockItemId: id,
+            type: 'ADJUSTMENT',
+            quantity: correction,
+            userId: actingUserId,
+            notes: 'Korrektur über Artikel bearbeiten',
+          },
+        });
+      }
+      return updated;
     });
     await this.auditLog.record({
       entityType: 'StockItem',