diff --git a/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json b/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json
index 99e43ec177555457ce0641f2986e54a577c51a93..3e0833b92c89f5e1b0b878a1d15aeb436fdc15bf 100644
--- a/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json
+++ b/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json
@@ -2,7 +2,6 @@
 	"createdAt": {
 		"$date": "2021-03-17T08:43:52.741Z"
 	},
-	"createdBy": "",
-	"createdByName": "Karl Kommentar",
+	"createdBy": "Karl Kommentar",
 	"text": "Test text to test the test text test"
 }
\ No newline at end of file
diff --git a/goofy-client/apps/goofy-e2e/src/model/kommentar.ts b/goofy-client/apps/goofy-e2e/src/model/kommentar.ts
index 9efe8cf5188a92da9ddcae5204dc92ff20943fc6..5ce513a6c91f1a9aa4309eed0c0719b2d75b7d61 100644
--- a/goofy-client/apps/goofy-e2e/src/model/kommentar.ts
+++ b/goofy-client/apps/goofy-e2e/src/model/kommentar.ts
@@ -3,6 +3,5 @@ import { DateE2E } from './util';
 export class KommentarE2E {
 	createdAt: DateE2E;
 	createdBy: string;
-	createdByName: string;
 	text: string;
 }
\ No newline at end of file
diff --git a/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts b/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts
index 940a89aac893fddb11bf28bbff6b3126900d443a..f220ad1714a2a0b10e1c1169f7dc80ad74d35f89 100644
--- a/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts
+++ b/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts
@@ -3,7 +3,7 @@ import { ListResource } from '@goofy-client/tech-shared';
 import { Resource } from '@ngxp/rest';
 
 export interface Kommentar {
-	createdByName: string;
+	createdBy: string;
 	createdAt: Date;
 	text: string;
 }
diff --git a/goofy-client/libs/kommentar-shared/test/kommentar.ts b/goofy-client/libs/kommentar-shared/test/kommentar.ts
index 820b8d9a047e169d96891431bc41c8290a2a2210..5d45e4904fd1fd630a401e3a15a4865af3220491 100644
--- a/goofy-client/libs/kommentar-shared/test/kommentar.ts
+++ b/goofy-client/libs/kommentar-shared/test/kommentar.ts
@@ -8,7 +8,7 @@ export function createKommentar(): Kommentar {
 	return {
 		text: faker.random.words(10),
 		createdAt: faker.date.past(),
-		createdByName: faker.random.words(2)
+		createdBy: faker.random.words(2)
 	}
 }
 
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java
index b3c47e8af27ec615e88062f22399c48dbf7563e4..f8e2c4cf1f1bde9745c1a9bac2a2caf4b595777e 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java
@@ -3,6 +3,7 @@ package de.itvsh.goofy.common.command;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
 
+import de.itvsh.goofy.kommentar.Kommentar;
 import de.itvsh.goofy.postfach.PostfachMail;
 import de.itvsh.goofy.vorgang.AssignUserCommandBody;
 import de.itvsh.goofy.vorgang.RedirectRequest;
@@ -12,7 +13,8 @@ import de.itvsh.goofy.wiedervorlage.Wiedervorlage;
 		@Type(value = PostfachMail.class, name = "SEND_POSTFACH_MAIL"),
 		@Type(value = AssignUserCommandBody.class, name = "ASSIGN_USER"),
 		@Type(value = RedirectRequest.class, name = "REDIRECT_VORGANG"),
-		@Type(value = Wiedervorlage.class, name = "WIEDERVORLAGE")
+		@Type(value = Wiedervorlage.class, name = "WIEDERVORLAGE"),
+		@Type(value = Kommentar.class, name = "KOMMENTAR")
 })
 public interface CommandBody {
 
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java
index dfb37d8f12b20ba1ae0ebc65d7b16f332fb79612..136cf4ea625bb8e60c4cdb2e07b0da5ae29551ab 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java
@@ -15,13 +15,13 @@ public enum CommandOrder {
 	VORGANG_ZURUECKSTELLEN(true, Type.VORGANG),
 	VORGANG_ABSCHLIESSEN(true, Type.VORGANG),
 	VORGANG_WIEDEREROEFFNEN(true, Type.VORGANG),
-	//
+
 	ASSIGN_USER(false, Type.VORGANG),
-	//
+
 	REDIRECT_VORGANG(false, Type.FORWARDING),
 	FORWARD_SUCCESSFULL(false, Type.FORWARDING),
 	FORWARD_FAILED(false, Type.FORWARDING),
-	//
+
 	CREATE_KOMMENTAR(false, Type.KOMMENTAR),
 	EDIT_KOMMENTAR(false, Type.KOMMENTAR),
 
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java
index 078b94223b11cfe8d625f8c7ae20a27127921a32..89eb1615fb6c468455689c949429c01e664907e6 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java
@@ -12,6 +12,7 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonProperty.Access;
 
 import de.itvsh.goofy.common.LinkedResource;
+import de.itvsh.goofy.common.command.CommandBody;
 import de.itvsh.goofy.common.user.UserProfileController;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -25,17 +26,18 @@ import lombok.ToString;
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 @AllArgsConstructor(access = AccessLevel.PACKAGE)
 @ToString
-public class Kommentar {
+public class Kommentar implements CommandBody {
 
 	@JsonIgnore
 	private String id;
 
+	@JsonIgnore
+	private String vorgangId;
+
 	@JsonProperty(access = Access.READ_ONLY)
 	@LinkedResource(controllerClass = UserProfileController.class)
 	private String createdBy;
 	@JsonProperty(access = Access.READ_ONLY)
-	private String createdByName;
-	@JsonProperty(access = Access.READ_ONLY)
 	private ZonedDateTime createdAt;
 
 	@NotNull(message = FIELD_IS_EMPTY)
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
index 764eead15d4c09eb1918a9ab6b2f7309554b6d14..b9040667714e68b01695b0ee0290d02d29e6b3cf 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java
@@ -2,6 +2,8 @@ package de.itvsh.goofy.kommentar;
 
 import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
 
+import java.time.ZonedDateTime;
+
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -10,26 +12,50 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import de.itvsh.goofy.common.command.Command;
 import de.itvsh.goofy.common.command.CommandController;
+import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
+import de.itvsh.goofy.common.command.CommandOrder;
+import de.itvsh.goofy.common.command.CreateCommand;
+import de.itvsh.goofy.common.user.CurrentUserService;
 
 @RestController
 @RequestMapping(KommentarCommandController.KOMMENTAR_COMMANDS)
 public class KommentarCommandController {
 
 	static final String KOMMENTAR_COMMANDS = "/api/kommentars/{kommentarId}/commands";
+	static final String NOT_SET = "-1";
 
 	@Autowired
 	private KommentarService service;
 
+	@Autowired
+	private CommandByRelationController commandByRelationController;
+
 	@PostMapping
-	public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand command, @PathVariable String kommentarId) {
-		return buildResponseLink(service.createCommand(kommentarId, command));
+	public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand kommentarCommand, @PathVariable String kommentarId) {
+		var command = commandByRelationController.createCommand(buildCommand(service.getById(kommentarId), kommentarCommand),
+				KommentarRemoteService.ITEM_NAME);
+		return buildResponseLink(command);
 	}
 
-	private ResponseEntity<Void> buildResponseLink(KommentarCommand createdKommentarCommand) {
+	private ResponseEntity<Void> buildResponseLink(Command createdKommentarCommand) {
 		return ResponseEntity.created(linkTo(CommandController.class).slash(createdKommentarCommand.getId()).toUri()).build();
 	}
 
+	CreateCommand buildCommand(Kommentar kommentar, KommentarCommand command) {
+		var commandBuilder = CreateCommand.builder()
+				.order(CommandOrder.UPDATE_ATTACHED_ITEM)
+				.relationId(NOT_SET)
+				.vorgangId(kommentar.getVorgangId());
+
+		return commandBuilder.body(updateKommandByCommand(kommentar, command)).build();
+	}
+
+	private Kommentar updateKommandByCommand(Kommentar kommentar, KommentarCommand command) {
+		return kommentar.toBuilder().text(command.getKommentar().getText()).build();
+	}
+
 	@RestController
 	@RequestMapping(KommentarCommandByVorgangController.KOMMENTAR_COMMANDS_BY_VORGANG)
 	public static class KommentarCommandByVorgangController {
@@ -37,13 +63,33 @@ public class KommentarCommandController {
 		static final String KOMMENTAR_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/kommentarCommands";
 
 		@Autowired
-		private KommentarService service;
+		private CommandByRelationController commandByRelationController;
+
+		@Autowired
+		private CurrentUserService userService;
 
 		@PostMapping()
 		public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand command, @PathVariable String vorgangId) {
-			var created = service.createCommand(vorgangId, command);
+			var createdCommand = commandByRelationController.createCommand(buildCommand(vorgangId, command), KommentarRemoteService.ITEM_NAME);
+
+			return ResponseEntity.created(linkTo(CommandController.class).slash(createdCommand.getId()).toUri()).build();
+		}
 
-			return ResponseEntity.created(linkTo(CommandController.class).slash(created.getId()).toUri()).build();
+		CreateCommand buildCommand(String vorgangId, KommentarCommand command) {
+			return CreateCommand.builder()
+					.vorgangId(vorgangId)
+					.order(CommandOrder.CREATE_ATTACHED_ITEM)
+					.relationId(NOT_SET)
+					.body(buildBody(command.getKommentar()))
+					.build();
 		}
+
+		Kommentar buildBody(Kommentar kommentar) {
+			return kommentar.toBuilder()
+					.createdAt(ZonedDateTime.now().withNano(0))
+					.createdBy(userService.getUserId().toString())
+					.build();
+		}
+
 	}
 }
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java
index 23263f80c3f20a7b8314a5658843a8ad0e25e58e..c36561d38afa4080e10c69b1782aa37e57095400 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java
@@ -1,5 +1,8 @@
 package de.itvsh.goofy.kommentar;
 
+import java.time.ZonedDateTime;
+import java.util.Map;
+
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.MappingConstants;
@@ -7,21 +10,27 @@ import org.mapstruct.NullValueCheckStrategy;
 import org.mapstruct.ReportingPolicy;
 import org.mapstruct.ValueMapping;
 
-import de.itvsh.goofy.common.IgnoreGrpcFields;
 import de.itvsh.ozg.pluto.grpc.command.GrpcCommand;
-import de.itvsh.ozg.pluto.kommentar.GrpcKommentar;
 
 @Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR, nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
 public interface KommentarMapper {
 
-	@Mapping(target = "textBytes", ignore = true)
-	@IgnoreGrpcFields
-	GrpcKommentar toGrpcKommentar(Kommentar kommentar);
-
-	Kommentar toKommentar(GrpcKommentar grpcKommentar);
+	static final String ID = "id";
+	static final String TEXT = "text";
+	static final String CREATED_BY = "createdBy";
+	static final String CREATED_AT = "createdAt";
 
 	@Mapping(target = "kommentar", ignore = true)
 	@ValueMapping(source = "UNRECOGNIZED", target = MappingConstants.NULL)
 	@ValueMapping(source = "UNDEFINED", target = MappingConstants.NULL)
 	KommentarCommand toKommentarCommand(GrpcCommand command);
+
+	default Kommentar fromItemMap(Map<String, Object> map) {
+		return Kommentar.builder()
+				.id((String) map.get(ID))
+				.createdAt(ZonedDateTime.parse((String) map.get(CREATED_AT)))
+				.createdBy((String) map.get(CREATED_BY))
+				.text((String) map.get(TEXT))
+				.build();
+	}
 }
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java
index ae337b684cfd9d475ace5e633f217364c2514092..11ee02a8f99dc649ec533afcafbb1a75a32c4299 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java
@@ -5,60 +5,48 @@ import java.util.stream.Stream;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import de.itvsh.goofy.common.callcontext.ContextService;
-import de.itvsh.ozg.pluto.grpc.command.GrpcCreateCommandRequest;
-import de.itvsh.ozg.pluto.grpc.command.GrpcOrder;
-import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdRequest;
-import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdResponse;
-import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarRequest;
-import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarResponse;
-import de.itvsh.ozg.pluto.kommentar.KommentarServiceGrpc.KommentarServiceBlockingStub;
+import de.itvsh.goofy.GoofyServerApplication;
+import de.itvsh.ozg.pluto.common.GrpcObjectMapper;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemRequest;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemRequest;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.VorgangAttachedItemServiceGrpc.VorgangAttachedItemServiceBlockingStub;
 import net.devh.boot.grpc.client.inject.GrpcClient;
 
 @Service
 class KommentarRemoteService {
+	static final String ITEM_NAME = "Kommentar";
 
-	@GrpcClient("pluto")
-	private KommentarServiceBlockingStub serviceStub;
-	@Autowired
-	private ContextService contextService;
+	@GrpcClient(GoofyServerApplication.GRPC_CLIENT)
+	private VorgangAttachedItemServiceBlockingStub vorgangAttachedItemServiceStub;
 	@Autowired
 	private KommentarMapper mapper;
+	@Autowired
+	private GrpcObjectMapper grpcObjectMapper;
 
 	public Stream<Kommentar> findByVorgangId(String vorgangId) {
-		GrpcFindKommentarsByVorgangIdResponse response = serviceStub
-				.findKommentarsByVorgangId(buildFindKommentarsByVorgangRequest(vorgangId));
+		GrpcFindVorgangAttachedItemResponse response = vorgangAttachedItemServiceStub
+				.find(buildFindRequest(vorgangId));
 
-		return response.getKommentarsList().stream().map(mapper::toKommentar);
+		return response.getVorgangAttachedItemsList().stream()
+				.map(item -> grpcObjectMapper.mapFromGrpc(item.getItem()))
+				.map(mapper::fromItemMap);
 	}
 
-	private GrpcFindKommentarsByVorgangIdRequest buildFindKommentarsByVorgangRequest(String vorgangId) {
-		return GrpcFindKommentarsByVorgangIdRequest.newBuilder().setVorgangId(vorgangId).build();
+	GrpcFindVorgangAttachedItemRequest buildFindRequest(String vorgangId) {
+		return GrpcFindVorgangAttachedItemRequest.newBuilder()
+				.setVorgangId(vorgangId)
+				.setItemName(ITEM_NAME)
+				.build();
 	}
 
 	public Kommentar getById(String kommentarId) {
-		GrpcGetKommentarResponse response = serviceStub.getKommentar(buildGetKommentarRequest(kommentarId));
-
-		return mapper.toKommentar(response.getKommentar());
-	}
-
-	private GrpcGetKommentarRequest buildGetKommentarRequest(String kommentarId) {
-		return GrpcGetKommentarRequest.newBuilder().setId(kommentarId).build();
+		var response = vorgangAttachedItemServiceStub.getById(buildRequest(kommentarId));
+		var kommentar = mapper.fromItemMap(grpcObjectMapper.mapFromGrpc(response.getVorgangAttachedItem().getItem()));
+		return kommentar.toBuilder().vorgangId(response.getVorgangAttachedItem().getVorgangId()).build();
 	}
 
-	public KommentarCommand sendKommentarCommand(String relationId, KommentarCommand command) {
-		var request = buildCreateCommandRequest(relationId, command);
-		var response = serviceStub.createCommand(request);
-
-		return mapper.toKommentarCommand(response.getCommand());
-	}
-
-	GrpcCreateCommandRequest buildCreateCommandRequest(String relationId, KommentarCommand command) {
-		return GrpcCreateCommandRequest.newBuilder()
-				.setCallContext(contextService.createCallContext())
-				.setRelationId(relationId)
-				.setOrder(GrpcOrder.valueOf(command.getOrder().name()))
-				.setKommentar(mapper.toGrpcKommentar(command.getKommentar()))
-				.build();
+	private GrpcVorgangAttachedItemRequest buildRequest(String kommentarId) {
+		return GrpcVorgangAttachedItemRequest.newBuilder().setId(kommentarId).build();
 	}
 }
diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
index 84b0c3fa3d435b273887d916c533f5e6f774e031..8b14e5f2262ef7a7628d9c2526f3704fa9654707 100644
--- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
+++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java
@@ -2,8 +2,6 @@ package de.itvsh.goofy.kommentar;
 
 import java.util.stream.Stream;
 
-import javax.validation.Valid;
-
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.validation.annotation.Validated;
@@ -22,8 +20,4 @@ class KommentarService {
 	public Kommentar getById(String kommentarId) {
 		return remoteService.getById(kommentarId);
 	}
-
-	public KommentarCommand createCommand(String relationId, @Valid KommentarCommand command) {
-		return remoteService.sendKommentarCommand(relationId, command);
-	}
 }
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java
deleted file mode 100644
index 6064c182ae49773e18bd7a6b57a612bfca5e9041..0000000000000000000000000000000000000000
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package de.itvsh.goofy.kommentar;
-
-import de.itvsh.ozg.pluto.kommentar.GrpcKommentar;
-
-public class GrpcKommentarTestFactory {
-
-	final static String ID = KommentarTestFactory.ID;
-	final static String CREATED_BY = KommentarTestFactory.CREATED_BY;
-	final static String CREATED_BY_NAME = KommentarTestFactory.CREATED_BY_NAME;
-	final static String CREATED_AT_STR = KommentarTestFactory.CREATED_AT_STR;
-	final static String TEXT = KommentarTestFactory.TEXT;
-
-	public static GrpcKommentar create() {
-		return createBuilder().build();
-	}
-
-	public static GrpcKommentar.Builder createBuilder() {
-		return GrpcKommentar.newBuilder()
-				.setId(ID)
-				.setCreatedBy(CREATED_BY)
-				.setCreatedByName(CREATED_BY_NAME)
-				.setCreatedAt(CREATED_AT_STR)
-				.setText(TEXT);
-	}
-}
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
index 2f67bba4bd69e06282af0f8d3519439c3c6616d1..3eb84c3ec6ae60f487ba067875086369004b81bc 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java
@@ -7,6 +7,8 @@ import static org.mockito.Mockito.*;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
+import java.util.UUID;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -19,14 +21,19 @@ import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.ResultActions;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 
+import de.itvsh.goofy.common.command.CommandController.CommandByRelationController;
 import de.itvsh.goofy.common.command.CommandOrder;
+import de.itvsh.goofy.common.command.CommandTestFactory;
+import de.itvsh.goofy.common.command.CreateCommand;
+import de.itvsh.goofy.common.user.CurrentUserService;
+import de.itvsh.goofy.common.user.UserId;
 import de.itvsh.goofy.kommentar.KommentarCommandController.KommentarCommandByVorgangController;
 import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
 
 class KommentarCommandControllerTest {
 
 	@Captor
-	private ArgumentCaptor<KommentarCommand> commandCaptor;
+	private ArgumentCaptor<CreateCommand> commandCaptor;
 
 	@Nested
 	class TestCreateKommentarCommandByVorgang {
@@ -35,13 +42,18 @@ class KommentarCommandControllerTest {
 		private KommentarCommandByVorgangController controller;
 		@Mock
 		private KommentarService service;
+		@Mock
+		private CommandByRelationController commandByRelationController;
+		@Mock
+		private CurrentUserService userService;
 
 		private MockMvc mockMvc;
 
 		@BeforeEach
 		void init() {
 			mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
-			when(service.createCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create());
+			when(userService.getUserId()).thenReturn(UserId.from(UUID.randomUUID()));
+			when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
 		}
 
 		@Test
@@ -53,19 +65,21 @@ class KommentarCommandControllerTest {
 		void shouldCallService() throws Exception {
 			doRequest();
 
-			verify(service).createCommand(eq(VorgangHeaderTestFactory.ID), notNull());
+			verify(commandByRelationController).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME));
 		}
 
 		@Test
 		void shouldGiveCommandToService() throws Exception {
 			doRequest();
 
-			verify(service).createCommand(eq(VorgangHeaderTestFactory.ID), commandCaptor.capture());
+			verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString());
 			var command = commandCaptor.getValue();
 
 			assertThat(command).usingRecursiveComparison()
-					.ignoringFields("kommentar.id", "kommentar.createdBy", "kommentar.createdByName", "kommentar.createdAt")
-					.isEqualTo(KommentarCommandTestFactory.createBuilder().id(null).build());
+					.ignoringFields("body", "status")
+					.isEqualTo(CommandTestFactory.createBuilder().order(CommandOrder.CREATE_ATTACHED_ITEM)
+							.relationId(KommentarCommandController.NOT_SET)
+							.id(null).build());
 		}
 
 		private ResultActions doRequest() throws Exception {
@@ -83,6 +97,8 @@ class KommentarCommandControllerTest {
 		@InjectMocks
 		private KommentarCommandController controller;
 		@Mock
+		private CommandByRelationController commandByRelationController;
+		@Mock
 		private KommentarService service;
 
 		private MockMvc mockMvc;
@@ -90,8 +106,8 @@ class KommentarCommandControllerTest {
 		@BeforeEach
 		void init() {
 			mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
-			when(service.createCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.createBuilder()
-					.order(CommandOrder.EDIT_KOMMENTAR).build());
+			when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
+			when(service.getById(any())).thenReturn(KommentarTestFactory.createBuilder().vorgangId(VorgangHeaderTestFactory.ID).build());
 		}
 
 		@Test
@@ -103,19 +119,21 @@ class KommentarCommandControllerTest {
 		void shouldCallService() throws Exception {
 			doRequest();
 
-			verify(service).createCommand(anyString(), notNull());
+			verify(service).getById(any());
 		}
 
 		@Test
 		void shouldGiveCommandToService() throws Exception {
 			doRequest();
 
-			verify(service).createCommand(anyString(), commandCaptor.capture());
+			verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString());
 			var command = commandCaptor.getValue();
 
 			assertThat(command).usingRecursiveComparison()
-					.ignoringFields("kommentar.id", "kommentar.createdBy", "kommentar.createdByName", "kommentar.createdAt")
-					.isEqualTo(KommentarCommandTestFactory.createBuilder().id(null).build());
+					.ignoringFields("body", "status")
+					.isEqualTo(CommandTestFactory.createBuilder().order(CommandOrder.UPDATE_ATTACHED_ITEM)
+							.relationId(KommentarCommandController.NOT_SET).id(null)
+							.build());
 		}
 
 		@Test
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
index 000d82d4797926a848d0445e598241f7148f7d74..37c96c2c937358f455fab7fcc967503267cf42ab 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java
@@ -22,6 +22,8 @@ import org.springframework.test.web.servlet.ResultActions;
 
 import de.itvsh.goofy.common.ValidationMessageCodes;
 import de.itvsh.goofy.common.command.CommandOrder;
+import de.itvsh.goofy.common.command.CommandRemoteService;
+import de.itvsh.goofy.common.command.CommandTestFactory;
 import de.itvsh.goofy.kommentar.KommentarCommandController.KommentarCommandByVorgangController;
 import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
 
@@ -34,6 +36,8 @@ class KommentarCommandITCase {
 	private MockMvc mockMvc;
 	@MockBean
 	private KommentarRemoteService remoteService;
+	@MockBean
+	private CommandRemoteService commandRemoteService;
 
 	@WithMockUser
 	@Nested
@@ -41,14 +45,15 @@ class KommentarCommandITCase {
 
 		@BeforeEach
 		void initTest() {
-			when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create());
+			when(remoteService.getById(any())).thenReturn(KommentarTestFactory.create());
+			when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
 		}
 
 		@Test
 		void shouldCreateCommand() throws Exception {
 			doRequestByKommentarId(createValidRequestContent()).andExpect(status().isCreated());
 
-			verify(remoteService).sendKommentarCommand(eq(KommentarTestFactory.ID), any());
+			verify(commandRemoteService).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME));
 		}
 
 		@WithMockUser
@@ -63,7 +68,7 @@ class KommentarCommandITCase {
 
 				doRequestByKommentarId(content).andExpect(status().isUnprocessableEntity())
 						.andExpect(jsonPath("$.issues.length()").value(1))
-						.andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text"))
+						.andExpect(jsonPath("$.issues.[0].field").value("command.body.text"))
 						.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY));
 			}
 
@@ -73,7 +78,7 @@ class KommentarCommandITCase {
 				String content = buildContentWithText(StringUtils.EMPTY);
 
 				doRequestByKommentarId(content).andExpect(status().isUnprocessableEntity())
-						.andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text"));
+						.andExpect(jsonPath("$.issues.[0].field").value("command.body.text"));
 
 			}
 
@@ -88,7 +93,7 @@ class KommentarCommandITCase {
 
 			private String buildContentWithText(String text) {
 				return createRequestContent(KommentarCommandTestFactory.createBuilder()
-						.order(CommandOrder.EDIT_KOMMENTAR)
+						.order(CommandOrder.CREATE_ATTACHED_ITEM)
 						.kommentar(KommentarTestFactory.createBuilder().text(text).build())
 						.build());
 			}
@@ -107,14 +112,15 @@ class KommentarCommandITCase {
 
 		@BeforeEach
 		void initTest() {
-			when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create());
+			when(remoteService.getById(any())).thenReturn(KommentarTestFactory.create());
+			when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create());
 		}
 
 		@Test
 		void shouldCreateCommand() throws Exception {
 			doRequestByVorgangId(createValidRequestContent()).andExpect(status().isCreated());
 
-			verify(remoteService).sendKommentarCommand(eq(VorgangHeaderTestFactory.ID), any());
+			verify(commandRemoteService).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME));
 		}
 
 		@WithMockUser
@@ -129,7 +135,7 @@ class KommentarCommandITCase {
 
 				doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity())
 						.andExpect(jsonPath("$.issues.length()").value(1))
-						.andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text"))
+						.andExpect(jsonPath("$.issues.[0].field").value("command.body.text"))
 						.andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY));
 			}
 
@@ -139,7 +145,7 @@ class KommentarCommandITCase {
 				String content = buildContentWithText(StringUtils.EMPTY);
 
 				doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity())
-						.andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text"));
+						.andExpect(jsonPath("$.issues.[0].field").value("command.body.text"));
 
 			}
 
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java
index 379f512ecf1106daa56f4fcdc075dfa559db6642..74380e47bbbb5e6315f72c9cac7853d6aaf961a2 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java
@@ -11,39 +11,37 @@ class KommentarMapperTest {
 	private KommentarMapper mapper = Mappers.getMapper(KommentarMapper.class);
 
 	@Nested
-	class TestFromGrpc {
-
+	class TestFromItemMap {
 		@Test
-		void shouldMap() {
-			var kommentar = mapper.toKommentar(GrpcKommentarTestFactory.create());
+		void shouldMapId() {
+			var kommentar = map();
 
-			assertThat(kommentar).isNotNull().usingRecursiveComparison().isEqualTo(KommentarTestFactory.create());
+			assertThat(kommentar.getId()).isEqualTo(KommentarTestFactory.ID);
 		}
 
 		@Test
-		void shouldHandleNull() {
-			var grpcKommentar = mapper.toKommentar(null);
+		void shouldMapCreatedBy() {
+			var kommentar = map();
 
-			assertThat(grpcKommentar).isNull();
+			assertThat(kommentar.getCreatedBy()).isEqualTo(KommentarTestFactory.CREATED_BY);
 		}
-	}
-
-	@Nested
-	class TestToGrpc {
 
 		@Test
-		void shouldMap() {
-			var grpcKommentar = mapper.toGrpcKommentar(KommentarTestFactory.createBuilder().id(null).build());
+		void shouldMapCreatedAt() {
+			var kommentar = map();
 
-			assertThat(grpcKommentar).isNotNull().usingRecursiveComparison().ignoringFields("id_", "memoizedHashCode")
-					.isEqualTo(GrpcKommentarTestFactory.create());
+			assertThat(kommentar.getCreatedAt()).isEqualTo(KommentarTestFactory.CREATED_AT);
 		}
 
 		@Test
-		void shouldHandleNull() {
-			var grpcKommentar = mapper.toGrpcKommentar(null);
+		void shouldMapText() {
+			var kommentar = map();
 
-			assertThat(grpcKommentar).isNull();
+			assertThat(kommentar.getText()).isEqualTo(KommentarTestFactory.TEXT);
 		}
 	}
+
+	private Kommentar map() {
+		return mapper.fromItemMap(KommentarTestFactory.createAsMap());
+	}
 }
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java
index 4e30b113e9e504fd110bda0daf2a9cdca21a1440..45ad4afbbbfec175aceb96ebc97e9c367875affa 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java
@@ -3,28 +3,24 @@ package de.itvsh.goofy.kommentar;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
 
-import de.itvsh.goofy.common.callcontext.ContextService;
-import de.itvsh.goofy.common.command.GrpcCommandResponseTestFactory;
+import de.itvsh.goofy.vorgang.GrpcVorgangAttachedItemTestFactory;
 import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory;
-import de.itvsh.ozg.pluto.grpc.command.GrpcCallContext;
-import de.itvsh.ozg.pluto.grpc.command.GrpcCommandResponse;
-import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdRequest;
-import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdResponse;
-import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarRequest;
-import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarResponse;
-import de.itvsh.ozg.pluto.kommentar.GrpcKommentar;
-import de.itvsh.ozg.pluto.kommentar.KommentarServiceGrpc.KommentarServiceBlockingStub;
+import de.itvsh.ozg.pluto.common.GrpcObjectMapper;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemRequest;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItem;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemRequest;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemResponse;
+import de.itvsh.ozg.pluto.vorgangAttachedItem.VorgangAttachedItemServiceGrpc.VorgangAttachedItemServiceBlockingStub;
 
 class KommentarRemoteServiceTest {
 
@@ -33,33 +29,34 @@ class KommentarRemoteServiceTest {
 	private KommentarRemoteService service;
 
 	@Mock
-	private KommentarMapper mapper;
+	private VorgangAttachedItemServiceBlockingStub vorgangAttachedItemServiceStub;
 	@Mock
-	private KommentarServiceBlockingStub serviceStub;
+	private KommentarMapper mapper;
 	@Mock
-	private ContextService contextService;
+	private GrpcObjectMapper grpcObjectMapper;
 
-	private GrpcKommentar kommentar = GrpcKommentarTestFactory.create();
+	private GrpcVorgangAttachedItem kommentar = GrpcVorgangAttachedItemTestFactory.create();
 
 	@Nested
 	class TestFindByVorgangId {
 
-		private GrpcFindKommentarsByVorgangIdRequest request = GrpcFindKommentarsByVorgangIdRequest.newBuilder()
-				.setVorgangId(VorgangHeaderTestFactory.ID).build();
-		private GrpcFindKommentarsByVorgangIdResponse response = GrpcFindKommentarsByVorgangIdResponse.newBuilder()
-				.addKommentars(kommentar)
-				.addKommentars(kommentar).build();
+		private GrpcFindVorgangAttachedItemRequest request = GrpcFindVorgangAttachedItemRequest.newBuilder()
+				.setVorgangId(VorgangHeaderTestFactory.ID).setItemName(KommentarRemoteService.ITEM_NAME).build();
+		private GrpcFindVorgangAttachedItemResponse response = GrpcFindVorgangAttachedItemResponse.newBuilder()
+				.clearVorgangAttachedItems()
+				.addVorgangAttachedItems(kommentar)
+				.addVorgangAttachedItems(kommentar).build();
 
 		@BeforeEach
 		void mockStub() {
-			when(serviceStub.findKommentarsByVorgangId(any())).thenReturn(response);
+			when(vorgangAttachedItemServiceStub.find(any())).thenReturn(response);
 		}
 
 		@Test
 		void shouldCallStub() {
 			service.findByVorgangId(VorgangHeaderTestFactory.ID);
 
-			verify(serviceStub).findKommentarsByVorgangId(request);
+			verify(vorgangAttachedItemServiceStub).find(request);
 		}
 
 		@Test
@@ -67,78 +64,39 @@ class KommentarRemoteServiceTest {
 			Stream<Kommentar> result = service.findByVorgangId(VorgangHeaderTestFactory.ID);
 			collectStreamElementsToTriggerLazyStream(result);
 
-			verify(mapper, times(2)).toKommentar(kommentar);
+			verify(mapper, times(2)).fromItemMap(any());
 		}
 
 		private void collectStreamElementsToTriggerLazyStream(Stream<Kommentar> stream) {
-			stream.collect(Collectors.toList());
+			stream.toList();
 		}
 	}
 
 	@Nested
 	class TestGetById {
-
-		private GrpcGetKommentarRequest request = GrpcGetKommentarRequest.newBuilder().setId(KommentarTestFactory.ID).build();
-		private GrpcGetKommentarResponse response = GrpcGetKommentarResponse.newBuilder().setKommentar(kommentar).build();
+		GrpcVorgangAttachedItemResponse response = GrpcVorgangAttachedItemResponse.newBuilder()
+				.setVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create()).build();
+		GrpcVorgangAttachedItemRequest request = GrpcVorgangAttachedItemRequest.newBuilder().setId(KommentarTestFactory.ID).build();
 
 		@BeforeEach
 		void mockStub() {
-			when(serviceStub.getKommentar(any())).thenReturn(response);
+			when(vorgangAttachedItemServiceStub.getById(any())).thenReturn(response);
+			when(grpcObjectMapper.mapFromGrpc(any())).thenReturn(KommentarTestFactory.createAsMap());
+			when(mapper.fromItemMap(any())).thenReturn(KommentarTestFactory.create());
 		}
 
 		@Test
 		void shouldCallStub() {
 			service.getById(KommentarTestFactory.ID);
 
-			verify(serviceStub).getKommentar(request);
+			verify(vorgangAttachedItemServiceStub).getById(request);
 		}
 
 		@Test
 		void shouldCallMapper() {
 			service.getById(KommentarTestFactory.ID);
 
-			verify(mapper).toKommentar(kommentar);
-		}
-	}
-
-	@Nested
-	class TestSendKommentarCommand {
-
-		private GrpcCallContext callContext = GrpcCallContext.newBuilder().build();
-		private GrpcCommandResponse response = GrpcCommandResponseTestFactory.createBuilder().build();
-
-		@BeforeEach
-		void initTest() {
-			when(serviceStub.createCommand(any())).thenReturn(response);
-			when(contextService.createCallContext()).thenReturn(callContext);
-			when(mapper.toGrpcKommentar(any())).thenReturn(GrpcKommentarTestFactory.create());
-			when(mapper.toKommentarCommand(any())).thenReturn(KommentarCommandTestFactory.create());
-		}
-
-		@Test
-		@DisplayName("Should call buildCreateCommandRequest with VorgangId")
-		void shouldCallCreateRequestWithVorgangId() {
-			doRequest();
-
-			verify(service).buildCreateCommandRequest(eq(VorgangHeaderTestFactory.ID), any());
-		}
-
-		@Test
-		void shouldCallStub() {
-			doRequest();
-
-			verify(serviceStub).createCommand(any());
-		}
-
-		@Test
-		void shouldMapResult() {
-			doRequest();
-
-			verify(mapper).toKommentarCommand(any());
-		}
-
-		private void doRequest() {
-			service.sendKommentarCommand(VorgangHeaderTestFactory.ID, KommentarCommandTestFactory.create());
+			verify(mapper).fromItemMap(any());
 		}
 	}
 }
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
index 7d9853445c31029cbb39aace9a9e75a4bfb5937b..d7193d38b9d8ba7ae8385d7e2414f0e42a2d45e8 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java
@@ -1,7 +1,5 @@
 package de.itvsh.goofy.kommentar;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.jupiter.api.Nested;
@@ -40,27 +38,4 @@ class KommentarServiceTest {
 			verify(remoteService).findByVorgangId(VorgangHeaderTestFactory.ID);
 		}
 	}
-
-	@Nested
-	class TestCreateCommand {
-
-		@Test
-		void shouldCallRemoteService() {
-			KommentarCommand command = KommentarCommandTestFactory.create();
-
-			service.createCommand(VorgangHeaderTestFactory.ID, command);
-
-			verify(remoteService).sendKommentarCommand(VorgangHeaderTestFactory.ID, command);
-		}
-
-		@Test
-		void shouldReturnCorrectResult() {
-			KommentarCommand resultFromRemoteService = KommentarCommandTestFactory.create();
-			when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(resultFromRemoteService);
-
-			KommentarCommand resultFromService = service.createCommand(VorgangHeaderTestFactory.ID, KommentarCommandTestFactory.create());
-
-			assertThat(resultFromService).isSameAs(resultFromRemoteService);
-		}
-	}
 }
diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java
index 2d7b464ec849994bd06cb7b89214ff491b7dd3bf..99abb0b24b22ca5ab6743ae4de507409dfdf0995 100644
--- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java
+++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java
@@ -1,6 +1,7 @@
 package de.itvsh.goofy.kommentar;
 
 import java.time.ZonedDateTime;
+import java.util.Map;
 import java.util.UUID;
 
 import com.thedeanda.lorem.Lorem;
@@ -15,7 +16,6 @@ public class KommentarTestFactory {
 	public static final String ID = UUID.randomUUID().toString();
 
 	public static final String CREATED_BY = UserProfileTestFactory.ID.toString();
-	public static final String CREATED_BY_NAME = lorem.getName();
 	public static final String CREATED_AT_STR = "2021-01-10T10:30:00Z";
 	public static final ZonedDateTime CREATED_AT = ZonedDateTime.parse(CREATED_AT_STR);
 
@@ -30,7 +30,14 @@ public class KommentarTestFactory {
 				.id(ID)
 				.text(TEXT)
 				.createdBy(CREATED_BY)
-				.createdByName(CREATED_BY_NAME)
 				.createdAt(CREATED_AT);
 	}
+
+	public static Map<String, Object> createAsMap() {
+		return Map.of(
+				KommentarMapper.ID, ID,
+				KommentarMapper.TEXT, TEXT,
+				KommentarMapper.CREATED_BY, CREATED_BY,
+				KommentarMapper.CREATED_AT, CREATED_AT_STR);
+	}
 }