diff --git a/src/main/java/org/eclipse/openk/contactbasedata/constants/Constants.java b/src/main/java/org/eclipse/openk/contactbasedata/constants/Constants.java
index 8b120eb..ef8cfd9 100644
--- a/src/main/java/org/eclipse/openk/contactbasedata/constants/Constants.java
+++ b/src/main/java/org/eclipse/openk/contactbasedata/constants/Constants.java
@@ -15,6 +15,8 @@
 package org.eclipse.openk.contactbasedata.constants;
 
 public final class Constants {
+    public static final String PERSON_TYPE_UUID_NOT_EXISTING = "personType.uuid.not.existing";
+
     private Constants() {
         // empty Constructor for the sake of SONAR
     }
diff --git a/src/main/java/org/eclipse/openk/contactbasedata/controller/PersonTypeController.java b/src/main/java/org/eclipse/openk/contactbasedata/controller/PersonTypeController.java
new file mode 100644
index 0000000..c56aec8
--- /dev/null
+++ b/src/main/java/org/eclipse/openk/contactbasedata/controller/PersonTypeController.java
@@ -0,0 +1,115 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************
+ */
+package org.eclipse.openk.contactbasedata.controller;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import lombok.extern.log4j.Log4j2;
+import org.eclipse.openk.contactbasedata.exceptions.BadRequestException;
+import org.eclipse.openk.contactbasedata.service.PersonTypeService;
+import org.eclipse.openk.contactbasedata.viewmodel.PersonTypeDto;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
+
+import java.net.URI;
+import java.util.List;
+import java.util.UUID;
+
+@Log4j2
+@RestController
+@RequestMapping("/personTypes")
+public class PersonTypeController {
+    @Autowired
+    private PersonTypeService personTypeService;
+
+    @ApiOperation(value = "Anzeigen aller Personentypen")
+    @Secured({"ROLE_KON-READER", "ROLE_KON-WRITER", "ROLE_KON-ADMIN"})
+    @ApiResponses(value = { @ApiResponse(code = 200, message = "Erfolgreich durchgeführt")})
+    @ResponseStatus(HttpStatus.OK)
+    @GetMapping
+    public List<PersonTypeDto> getPersonType() {
+        return personTypeService.findAllPersonTypes();
+    }
+
+
+
+    @GetMapping("/{personTypeUuid}")
+    @Secured({"ROLE_KON-READER", "ROLE_KON-WRITER", "ROLE_KON-ADMIN"})
+    @ApiOperation(value = "Suchen eines Personentyps per UUID")
+    @ResponseStatus(HttpStatus.OK)
+    @ApiResponses(value = {
+            @ApiResponse(code = 400, message = "Ungültige Anfrage."),
+            @ApiResponse(code = 200, message = "Personentyp gefunden")})
+    public PersonTypeDto getPersonType(@PathVariable UUID personTypeUuid) {
+
+        return personTypeService.getPersonTypeByUuid(personTypeUuid);
+    }
+
+
+    @PostMapping
+    @Secured("ROLE_KON-ADMIN")
+    @ApiOperation(value = "Anlegen eines neuen Personentyps")
+    @ApiResponses(value = {
+            @ApiResponse(code = 200, message = "Personentyp erfolgreich angelegt"),
+            @ApiResponse(code = 500, message = "Konnte nicht durchgeführt werden")
+    })
+    public ResponseEntity<PersonTypeDto> insertPersonType(@Validated @RequestBody PersonTypeDto personTypeDto) {
+        PersonTypeDto savedPersonTypeDto = personTypeService.insertPersonType(personTypeDto);
+        URI location = ServletUriComponentsBuilder
+                .fromCurrentRequestUri()
+                .path("/{uuid}")
+                .buildAndExpand(savedPersonTypeDto.getUuid())
+                .toUri();
+        return ResponseEntity.created(location).body(savedPersonTypeDto);
+    }
+
+
+    @PutMapping("/{personTypeUuid}")
+    @Secured("ROLE_KON-ADMIN")
+    @ApiOperation(value = "Ändern eines Personentyp")
+    @ApiResponses(value = {
+            @ApiResponse(code = 200, message = "Personentyp wurde erfolgreich aktualisiert"),
+            @ApiResponse(code = 400, message = "Ungültige Eingabe"),
+            @ApiResponse(code = 404, message = "Nicht gefunden")})
+    public ResponseEntity updatePersonType(@PathVariable UUID personTypeUuid, @Validated @RequestBody PersonTypeDto personTypeDto) {
+
+        if (!personTypeDto.getUuid().equals(personTypeUuid)) {
+            throw new BadRequestException("invalid.uuid.path.object");
+        }
+
+        personTypeService.updatePersonType(personTypeDto);
+        return ResponseEntity.ok().build();
+    }
+
+
+    @DeleteMapping("/{uuid}")
+    @Secured("ROLE_KON-ADMIN")
+    @ResponseStatus(HttpStatus.OK)
+    @ApiOperation(value = "Personentyp löschen")
+    @ApiResponses(value = {
+            @ApiResponse(code = 204, message = "Erfolgreich durchgeführt"),
+            @ApiResponse(code = 400, message = "Ungültige Anfrage"),
+            @ApiResponse(code = 404, message = "Nicht gefunden")})
+    public void removePersonType(@PathVariable UUID uuid) {
+        personTypeService.removePersonType(uuid);
+    }
+
+}
diff --git a/src/main/java/org/eclipse/openk/contactbasedata/mapper/PersonTypeMapper.java b/src/main/java/org/eclipse/openk/contactbasedata/mapper/PersonTypeMapper.java
index e68f8e3..fb4e3ee 100644
--- a/src/main/java/org/eclipse/openk/contactbasedata/mapper/PersonTypeMapper.java
+++ b/src/main/java/org/eclipse/openk/contactbasedata/mapper/PersonTypeMapper.java
@@ -23,4 +23,6 @@
 public interface PersonTypeMapper {
 
     PersonTypeDto toPersonTypeDto(RefPersonType refPersonType);
+
+    RefPersonType toRefPersonType(PersonTypeDto personTypeDto);
 }
diff --git a/src/main/java/org/eclipse/openk/contactbasedata/service/PersonTypeService.java b/src/main/java/org/eclipse/openk/contactbasedata/service/PersonTypeService.java
new file mode 100644
index 0000000..74f33f8
--- /dev/null
+++ b/src/main/java/org/eclipse/openk/contactbasedata/service/PersonTypeService.java
@@ -0,0 +1,86 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************
+ */
+package org.eclipse.openk.contactbasedata.service;
+
+import lombok.extern.log4j.Log4j2;
+import org.eclipse.openk.contactbasedata.constants.Constants;
+import org.eclipse.openk.contactbasedata.exceptions.BadRequestException;
+import org.eclipse.openk.contactbasedata.exceptions.NotFoundException;
+import org.eclipse.openk.contactbasedata.mapper.PersonTypeMapper;
+import org.eclipse.openk.contactbasedata.model.RefPersonType;
+import org.eclipse.openk.contactbasedata.repository.PersonTypeRepository;
+import org.eclipse.openk.contactbasedata.viewmodel.PersonTypeDto;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Log4j2
+@Service
+public class PersonTypeService {
+    @Autowired
+    private PersonTypeRepository personTypeRepository;
+
+    @Autowired
+    PersonTypeMapper personTypeMapper;
+
+    public List<PersonTypeDto> findAllPersonTypes() {
+        return personTypeRepository.findAll().stream()
+                    .map( personTypeMapper::toPersonTypeDto )
+                    .collect(Collectors.toList());
+    }
+
+
+    public PersonTypeDto getPersonTypeByUuid(UUID personTypeUuid) {
+        RefPersonType refPersonType = personTypeRepository
+                .findByUuid(personTypeUuid)
+                .orElseThrow(() -> new NotFoundException(Constants.PERSON_TYPE_UUID_NOT_EXISTING));
+        return personTypeMapper.toPersonTypeDto(refPersonType);
+    }
+
+    @Transactional
+    public PersonTypeDto insertPersonType(PersonTypeDto personTypeDto) {
+        RefPersonType personTypeToSave = personTypeMapper.toRefPersonType(personTypeDto);
+        personTypeToSave.setUuid(UUID.randomUUID());
+
+        RefPersonType savedPersonType = personTypeRepository.save(personTypeToSave);
+        return personTypeMapper.toPersonTypeDto(savedPersonType);
+    }
+
+    @Transactional
+    public PersonTypeDto updatePersonType(PersonTypeDto personTypeDto){
+        RefPersonType personTypeUpdated;
+        RefPersonType personTypeToSave = personTypeMapper.toRefPersonType(personTypeDto);
+        RefPersonType existingPersonType = personTypeRepository
+                .findByUuid(personTypeDto.getUuid())
+                .orElseThrow(() -> new NotFoundException("personType.uuid.not.existing"));
+        personTypeToSave.setId(existingPersonType.getId());
+        personTypeUpdated = personTypeRepository.save(personTypeToSave);
+
+        return personTypeMapper.toPersonTypeDto(personTypeUpdated);
+    }
+
+    @Transactional
+    public void removePersonType(UUID uuid) {
+        RefPersonType existingPersonType = personTypeRepository.findByUuid(uuid)
+                .orElseThrow( () -> new BadRequestException("personType.uuid.not.existing"));
+
+        personTypeRepository.delete(existingPersonType);
+    }
+
+}
diff --git a/src/test/java/org/eclipse/openk/contactbasedata/config/TestConfiguration.java b/src/test/java/org/eclipse/openk/contactbasedata/config/TestConfiguration.java
index 8323d28..6ebab0c 100644
--- a/src/test/java/org/eclipse/openk/contactbasedata/config/TestConfiguration.java
+++ b/src/test/java/org/eclipse/openk/contactbasedata/config/TestConfiguration.java
@@ -48,6 +48,9 @@
     SalutationMapper salutationMapper() { return new SalutationMapperImpl(); }
 
     @Bean
+    PersonTypeMapper personTypeMapper() { return new PersonTypeMapperImpl(); }
+
+    @Bean
     AddressMapper addressMapper() { return new AddressMapperImpl(); }
 
     @Bean
@@ -71,6 +74,9 @@
     public SalutationService mySalutationService() { return new SalutationService(); }
 
     @Bean
+    public PersonTypeService myPersonTypeService() { return new PersonTypeService(); }
+
+    @Bean
     public AddressService myAddressService() { return new AddressService(); }
 
     @Bean
diff --git a/src/test/java/org/eclipse/openk/contactbasedata/controller/PersonTypeControllerTest.java b/src/test/java/org/eclipse/openk/contactbasedata/controller/PersonTypeControllerTest.java
new file mode 100644
index 0000000..9379b1b
--- /dev/null
+++ b/src/test/java/org/eclipse/openk/contactbasedata/controller/PersonTypeControllerTest.java
@@ -0,0 +1,123 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************
+ */
+package org.eclipse.openk.contactbasedata.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.eclipse.openk.contactbasedata.ContactBaseDataApplication;
+import org.eclipse.openk.contactbasedata.service.PersonTypeService;
+import org.eclipse.openk.contactbasedata.support.MockDataHelper;
+import org.eclipse.openk.contactbasedata.viewmodel.PersonTypeDto;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@SpringBootTest(classes = ContactBaseDataApplication.class)
+@AutoConfigureMockMvc
+@ActiveProfiles("test") // Todo: Find a better way to configure the tests
+public class PersonTypeControllerTest {
+
+    @MockBean
+    private PersonTypeService saluationService;
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Test
+    public void shouldReturnAllPersonTypes() throws Exception {
+        List<PersonTypeDto> sds = MockDataHelper.mockPersonTypesDtos();
+
+        when(saluationService.findAllPersonTypes()).thenReturn(sds);
+
+        mockMvc.perform(get("/personTypes"))
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON));
+    }
+
+    @Test
+    public void shouldReturnSinglePersonType() throws Exception {
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+
+        when(saluationService.getPersonTypeByUuid(any(UUID.class))).thenReturn(personTypeDto);
+
+        mockMvc.perform(get("/personTypes/37454f86-2006-11ea-978f-2e728ce88125"))
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON));
+    }
+
+    @Test
+    public void shouldInsertPersonType() throws Exception {
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+        personTypeDto.setType("Master");
+        personTypeDto.setDescription("of the universe");
+
+        when(saluationService.insertPersonType(any(PersonTypeDto.class)))
+                .thenReturn(personTypeDto);
+
+        mockMvc.perform(post("/personTypes")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(new ObjectMapper().writeValueAsString(personTypeDto)))
+                .andExpect(jsonPath("$.type", Matchers.is("Master")))
+                .andExpect(jsonPath("$.description", Matchers.is("of the universe" )));
+    }
+
+    @Test
+    public void shouldUpdatePersonType() throws Exception {
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+        personTypeDto.setUuid(UUID.randomUUID());
+
+        when(  saluationService.updatePersonType(any(PersonTypeDto.class))).thenReturn(personTypeDto);
+
+        mockMvc.perform(put("/personTypes/{uuid}", personTypeDto.getUuid().toString())
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(new ObjectMapper().writeValueAsString(personTypeDto)))
+                .andExpect(status().is2xxSuccessful());
+    }
+
+    @Test
+    public void shouldNotUpdatePersonTypeDueToError() throws Exception {
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+        personTypeDto.setUuid(UUID.randomUUID());
+
+        when(  saluationService.updatePersonType(any(PersonTypeDto.class))).thenReturn(personTypeDto);
+
+        // use different UUIDs for path and object
+        mockMvc.perform(put("/personTypes/{uuid}", UUID.randomUUID().toString())
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(new ObjectMapper().writeValueAsString(personTypeDto)))
+                .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    public void shouldDeletePersonType() throws Exception {
+        mockMvc.perform(delete("/personTypes/05ff2344-20a5-11ea-978f-2e728ce88125")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().is2xxSuccessful());
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/org/eclipse/openk/contactbasedata/service/PersonTypeServiceTest.java b/src/test/java/org/eclipse/openk/contactbasedata/service/PersonTypeServiceTest.java
new file mode 100644
index 0000000..d6484a1
--- /dev/null
+++ b/src/test/java/org/eclipse/openk/contactbasedata/service/PersonTypeServiceTest.java
@@ -0,0 +1,123 @@
+/*
+ *******************************************************************************
+ * Copyright (c) 2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************
+ */
+package org.eclipse.openk.contactbasedata.service;
+
+import org.eclipse.openk.contactbasedata.config.TestConfiguration;
+import org.eclipse.openk.contactbasedata.model.RefPersonType;
+import org.eclipse.openk.contactbasedata.repository.PersonTypeRepository;
+import org.eclipse.openk.contactbasedata.support.MockDataHelper;
+import org.eclipse.openk.contactbasedata.viewmodel.PersonTypeDto;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.test.context.ContextConfiguration;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.hibernate.validator.internal.util.Contracts.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
+
+@DataJpaTest
+@ContextConfiguration(classes = {TestConfiguration.class})
+
+public class PersonTypeServiceTest {
+    @Qualifier("myPersonTypeService")
+    @Autowired
+    private PersonTypeService personTypeService;
+
+    @MockBean
+    private PersonTypeRepository personTypeRepository;
+
+    @Test
+    public void shouldFindAllPersonTypesProperly() {
+        List<RefPersonType> rs = MockDataHelper.mockRefPersonTypes();
+        when(personTypeRepository.findAll()).thenReturn(rs);
+        List<PersonTypeDto> retVals = personTypeService.findAllPersonTypes();
+
+        assertEquals(rs.size(), retVals.size());
+        assertEquals(rs.size(), 2);
+        assertEquals(rs.get(1).getUuid(), retVals.get(1).getUuid());
+    }
+
+
+    @Test
+    public void shouldReturnPersonTypeByUuid() {
+
+        RefPersonType refPersonType = MockDataHelper.mockRefPersonType();
+        refPersonType.setType("Testtyp");
+        when( personTypeRepository.findByUuid( any(UUID.class)) ).thenReturn(Optional.of(refPersonType));
+
+        PersonTypeDto personTypeDto = personTypeService.getPersonTypeByUuid(UUID.randomUUID());
+        assertEquals( personTypeDto.getUuid(), refPersonType.getUuid() );
+        assertEquals( personTypeDto.getType(), refPersonType.getType() );
+    }
+
+    @Test
+    public void shouldInsertPersonType(){
+        RefPersonType refPersonType = MockDataHelper.mockRefPersonType();
+
+        refPersonType.setUuid(UUID.fromString("1468275e-200b-11ea-978f-2e728ce88125"));
+        refPersonType.setType("Kein guter Mensch");
+        refPersonType.setDescription("heutiger Standard Personentyp");
+
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+        personTypeDto.setUuid(null);
+
+        when( personTypeRepository.save( any( RefPersonType.class) )).thenReturn(refPersonType);
+
+        PersonTypeDto savedPersonTypeDto = personTypeService.insertPersonType(personTypeDto);
+        assertEquals("Kein guter Mensch", savedPersonTypeDto.getType());
+        assertNotNull( savedPersonTypeDto.getUuid());
+    }
+
+    @Test
+    public void shouldUpdatePersonType() {
+
+        RefPersonType personType = MockDataHelper.mockRefPersonType();
+        personType.setType("Kein schöner Mensch");
+
+        PersonTypeDto personTypeDto = MockDataHelper.mockPersonTypeDto();
+        personTypeDto.setType("Kein guter Mensch");
+
+        when( personTypeRepository.findByUuid( any(UUID.class)) ).thenReturn(Optional.of(personType));
+        when( personTypeRepository.save( any(RefPersonType.class)) ).thenReturn(personType);
+        PersonTypeDto personTypeDtoUpdated = personTypeService.updatePersonType(personTypeDto);
+
+        assertEquals(personType.getUuid(), personTypeDtoUpdated.getUuid());
+        assertEquals("Kein schöner Mensch", personTypeDtoUpdated.getType());
+    }
+
+
+    @Test
+    public void shouldDeletePersonType() {
+
+        RefPersonType personType = MockDataHelper.mockRefPersonType();
+
+        when(personTypeRepository.findByUuid(any(UUID.class))).thenReturn(Optional.of(personType));
+        Mockito.doNothing().when(personTypeRepository).delete( isA( RefPersonType.class ));
+        personTypeService.removePersonType(personType.getUuid());
+
+        Mockito.verify(personTypeRepository, times(1)).delete( personType );
+    }
+}
diff --git a/src/test/java/org/eclipse/openk/contactbasedata/support/MockDataHelper.java b/src/test/java/org/eclipse/openk/contactbasedata/support/MockDataHelper.java
index 8827800..17ab147 100644
--- a/src/test/java/org/eclipse/openk/contactbasedata/support/MockDataHelper.java
+++ b/src/test/java/org/eclipse/openk/contactbasedata/support/MockDataHelper.java
@@ -132,14 +132,43 @@
     }
 
     public static RefPersonType mockRefPersonType() {
-        RefPersonType pt = new RefPersonType();
-        pt.setId(6L);
-        pt.setUuid(UUID.randomUUID());
-        pt.setDescription("Ehrenmann");
-        pt.setType("ehrenmann");
-        return pt;
+        RefPersonType refPersonType = new RefPersonType();
+        refPersonType.setId(1L);
+        refPersonType.setUuid(UUID.randomUUID());
+        refPersonType.setDescription("Ehrenmann");
+        refPersonType.setType("ElCapitan");
+        return refPersonType;
     }
 
+    public static PersonTypeDto mockPersonTypeDto() {
+        PersonTypeDto personTypeDto = new PersonTypeDto();
+        personTypeDto.setUuid(UUID.randomUUID());
+        personTypeDto.setDescription("Ehrenmann");
+        personTypeDto.setType("ElCapitan");
+        return personTypeDto;
+    }
+
+    public static List<PersonTypeDto> mockPersonTypesDtos() {
+        List<PersonTypeDto> dtos = new LinkedList<>();
+        dtos.add( mockPersonTypeDto() );
+        PersonTypeDto sd2 = mockPersonTypeDto();
+        sd2.setType("Gutmensch");
+        sd2.setDescription("Zu guter Mensch");
+        dtos.add( sd2 );
+        return dtos;
+    }
+
+    public static List<RefPersonType> mockRefPersonTypes() {
+        List<RefPersonType> refs = new LinkedList<>();
+        refs.add( mockRefPersonType() );
+        RefPersonType sd2 = mockRefPersonType();
+        sd2.setType("Gutmensch");
+        sd2.setDescription("Zu guter Mensch");
+        refs.add( sd2 );
+        return refs;
+    }
+
+
     public static TblAddress mockTblAddress(){
         TblAddress tblAddress = new TblAddress();