From 6a9672074ce53c2da19395dd9c504ef3458ea466 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Thu, 30 Apr 2020 14:22:34 +0200
Subject: [PATCH 01/17] Implement basic exposure contact person backend
 functionality

---
 .../imis/api/ExposureContactController.java   | 68 +++++++++++++++++++
 .../imis/api/dto/ExposureContactDTO.java      | 41 +++++++++++
 .../imis/config/SpringSecurityConfig.java     |  1 +
 .../imis/domain/ExposureContact.java          | 31 +++++++++
 .../de/coronavirus/imis/domain/Patient.java   | 26 +++++++
 .../imis/mapper/ExposureContactMapper.java    | 21 ++++++
 .../imis/mapper/PatientMapper.java            | 11 +++
 .../ExposureContactRepository.java            | 15 ++++
 8 files changed, 214 insertions(+)
 create mode 100644 server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
 create mode 100644 server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
 create mode 100644 server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
 create mode 100644 server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
 create mode 100644 server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java

diff --git a/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
new file mode 100644
index 00000000..47a0466d
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
@@ -0,0 +1,68 @@
+package de.coronavirus.imis.api;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import lombok.RequiredArgsConstructor;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import de.coronavirus.imis.api.dto.ExposureContactDTO;
+import de.coronavirus.imis.domain.ExposureContact;
+import de.coronavirus.imis.mapper.ExposureContactMapper;
+import de.coronavirus.imis.repositories.ExposureContactRepository;
+
+@RestController
+@RequestMapping("/api/exposure-contacts")
+@RequiredArgsConstructor
+public class ExposureContactController {
+  private final ExposureContactRepository exposureContactRepository;
+  private final ExposureContactMapper exposureContactMapper;
+
+  @PostMapping
+  public ExposureContactDTO.FromServer createExposureContact(@RequestBody ExposureContactDTO.ToServer dto) {
+    return exposureContactMapper.toExposureContactDTO(
+      exposureContactRepository.saveAndFlush(
+        exposureContactMapper.toExposureContact(dto)
+      )
+    );
+  }
+
+  @PutMapping
+  public ExposureContactDTO.FromServer updateExposureContact(@RequestBody ExposureContactDTO.ToServer contact) {
+    return exposureContactMapper.toExposureContactDTO(
+      exposureContactRepository.saveAndFlush(
+        exposureContactMapper.toExposureContact(contact)
+      )
+    );
+  }
+
+  @GetMapping("/{id}")
+  public ExposureContactDTO.FromServer getExposureContact(@PathVariable("id") long id) {
+    return exposureContactMapper.toExposureContactDTO(exposureContactRepository.findById(id).orElse(null));
+  }
+
+  @GetMapping("/by-source/{id}")
+  public List<ExposureContactDTO.FromServer> getExposureContactsForPatient(@PathVariable("id") String patientId) {
+    return exposureContactRepository.findBySourceId(patientId)
+      .stream().map(contact -> exposureContactMapper.toExposureContactDTO(contact))
+      .collect(Collectors.toList());
+  }
+  @GetMapping("/by-contact/{id}")
+  public ExposureContactDTO.FromServer getExposureSourceContactForPatient(@PathVariable("id") String patientId) {
+    return exposureContactMapper.toExposureContactDTO(exposureContactRepository.findByContactId(patientId));
+  }
+
+  @DeleteMapping("/{id}")
+  public void removeExposureContact(@PathVariable("id") long id) {
+    this.exposureContactRepository.deleteById(id);
+  }
+}
diff --git a/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
new file mode 100644
index 00000000..1930bd7f
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
@@ -0,0 +1,41 @@
+package de.coronavirus.imis.api.dto;
+
+import java.time.LocalDate;
+
+import com.fasterxml.jackson.annotation.JsonUnwrapped;
+import io.swagger.annotations.ApiModel;
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+import de.coronavirus.imis.domain.Patient;
+
+public abstract class ExposureContactDTO {
+  @Data
+  public static class Common {
+    private long id;
+    private String context;
+    private String dateOfContact;
+    private String comment;
+  }
+
+  @ApiModel("ExposureContactToServer")
+  @Data
+  public static class ToServer {
+    private String source;
+    private String contact;
+
+    @JsonUnwrapped
+    private ExposureContactDTO.Common common;
+  }
+
+  @ApiModel("ExposureContactFromServer")
+  @Data
+  public static class FromServer {
+    private Patient.IdentityView source;
+    private Patient.IdentityView contact;
+
+    @JsonUnwrapped
+    private ExposureContactDTO.Common common;
+  }
+}
diff --git a/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java b/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
index 738c1658..24c14db0 100644
--- a/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
+++ b/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
@@ -62,6 +62,7 @@ protected void configure(HttpSecurity http) throws Exception {
 				.antMatchers(OPTIONS, "/**").permitAll()
 				.antMatchers("/api/auth").permitAll()
 				.antMatchers(API_PREFIX + "/patients").hasAnyRole(DEPARTMENT_OF_HEALTH, CLINIC, DOCTORS_OFFICE, TEST_SITE)
+				.antMatchers(API_PREFIX + "/exposure-contacts/**").permitAll()
 				.antMatchers(API_PREFIX + "/doctor/*").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC)
 				.mvcMatchers(POST, API_PREFIX + "/labtest").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC, TEST_SITE)
 				.antMatchers(API_PREFIX + "/labtest/patient/*").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC, TEST_SITE)
diff --git a/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java b/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
new file mode 100644
index 00000000..5d175721
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
@@ -0,0 +1,31 @@
+package de.coronavirus.imis.domain;
+
+import javax.persistence.*;
+import java.time.LocalDate;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import de.coronavirus.imis.mapper.PatientMapper;
+import de.coronavirus.imis.repositories.PatientRepository;
+
+@Entity
+@Component
+@Data
+@Accessors(chain = true)
+public class ExposureContact {
+
+	@Id
+	@GeneratedValue
+	private long id;
+
+	@ManyToOne
+	private Patient source;
+	@OneToOne
+	private Patient contact;
+	private String context; // e.g. contact in a medical facility
+	private LocalDate dateOfContact;
+	private String comment;
+}
diff --git a/server/src/main/java/de/coronavirus/imis/domain/Patient.java b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
index a8c2e69d..17d31a63 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/Patient.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
@@ -1,10 +1,15 @@
 package de.coronavirus.imis.domain;
 
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonIdentityInfo;
 import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+import io.swagger.annotations.ApiModel;
+import lombok.Builder;
 import lombok.Getter;
+import lombok.AllArgsConstructor;
 import lombok.NoArgsConstructor;
+import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
@@ -12,8 +17,12 @@
 import javax.validation.constraints.NotNull;
 import java.time.LocalDate;
 import java.time.OffsetDateTime;
+import java.util.Collections;
 import java.util.List;
 
+import de.coronavirus.imis.domain.ExposureContact;
+import de.coronavirus.imis.repositories.ExposureContactRepository;
+
 
 @Entity
 @Getter
@@ -61,6 +70,14 @@ public class Patient {
 	@Convert(converter = StringListConverter.class)
 	private List<String> symptoms;
 	private Boolean coronaContacts;
+
+	@JsonIgnore
+	@OneToOne(mappedBy = "contact")
+	private ExposureContact exposureSourceContact;
+	@JsonIgnore
+	@OneToMany(mappedBy = "source")
+	private List<ExposureContact> exposureContacts;
+
 	@Convert(converter = StringListConverter.class)
 	private List<String> riskAreas;
 	private Boolean weakenedImmuneSystem;
@@ -77,4 +94,13 @@ public class Patient {
 	private Boolean onIntensiveCareUnit;
 
 	private LocalDate quarantineUntil;
+
+	@ApiModel("PatientIdentity")
+	@Getter
+	@Setter
+	public static class IdentityView {
+		private String id;
+		private String firstName;
+		private String lastName;
+	}
 }
diff --git a/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java b/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
new file mode 100644
index 00000000..83fcb1a5
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
@@ -0,0 +1,21 @@
+package de.coronavirus.imis.mapper;
+
+import de.coronavirus.imis.api.dto.ExposureContactDTO;
+import de.coronavirus.imis.domain.ExposureContact;
+import de.coronavirus.imis.mapper.PatientMapper;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+
+@Mapper(uses = PatientMapper.class)
+public abstract class ExposureContactMapper {
+
+  @Mapping(target = "id", source = "common.id")
+  @Mapping(target = "context", source = "common.context")
+  @Mapping(target = "dateOfContact", source = "common.dateOfContact")
+  @Mapping(target = "comment", source = "common.comment")
+  public abstract ExposureContact toExposureContact(ExposureContactDTO.ToServer dto);
+
+  @Mapping(target = "common", source = ".")
+  public abstract ExposureContactDTO.FromServer toExposureContactDTO(ExposureContact contact);
+}
diff --git a/server/src/main/java/de/coronavirus/imis/mapper/PatientMapper.java b/server/src/main/java/de/coronavirus/imis/mapper/PatientMapper.java
index 67a1b926..593287ee 100644
--- a/server/src/main/java/de/coronavirus/imis/mapper/PatientMapper.java
+++ b/server/src/main/java/de/coronavirus/imis/mapper/PatientMapper.java
@@ -2,8 +2,10 @@
 
 import de.coronavirus.imis.api.dto.CreatePatientDTO;
 import de.coronavirus.imis.domain.Patient;
+import de.coronavirus.imis.repositories.PatientRepository;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import java.time.LocalDate;
 import java.time.OffsetDateTime;
@@ -15,6 +17,9 @@ public abstract class PatientMapper {
 	public static final String DATE_FORMAT = "yyyy-MM-dd";
 	public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DATE_FORMAT);
 
+	@Autowired
+	private PatientRepository patientRepository;
+
 	@Mapping(target = "patientStatus", defaultValue = "REGISTERED")
 	@Mapping(target = "creationTimestamp", expression = "java( OffsetDateTime.now() )")
 	@Mapping(target = "dateOfBirth", dateFormat = DATE_FORMAT)
@@ -26,6 +31,12 @@ public abstract class PatientMapper {
 	@Mapping(target = "events", ignore = true)
 	public abstract Patient toPatient(CreatePatientDTO createPatient);
 
+	public Patient toPatient(String id) {
+		return id != null ? patientRepository.findById(id).orElse(null) : null;
+	}
+
+	public abstract Patient.IdentityView toIdentityView(Patient patient);
+
 	public LocalDate parseDate(String localDateString) {
 		LocalDate localDate = null;
 		if (localDateString != null && !localDateString.isBlank()) {
diff --git a/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
new file mode 100644
index 00000000..736aee49
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
@@ -0,0 +1,15 @@
+package de.coronavirus.imis.repositories;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+import de.coronavirus.imis.domain.ExposureContact;
+
+public interface ExposureContactRepository extends JpaRepository<ExposureContact, Long> {
+
+	List<ExposureContact> findBySourceId(String patientId);
+	ExposureContact findByContactId(String patientId);
+}

From 40010884abd4c0d5f52b9b4be1bea2ccb62f6b89 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Thu, 30 Apr 2020 17:11:26 +0200
Subject: [PATCH 02/17] Add infection and quarantine status to exposure
 contact's contact object

---
 .gitignore                                    |  3 +++
 .../imis/api/dto/ExposureContactDTO.java      | 14 +++++++++++--
 .../imis/mapper/ExposureContactMapper.java    | 20 ++++++++++++++++++-
 3 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6d75aeb7..e4de8bcb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,9 @@
 .idea
 .gradle
 .DS_Store
+**/.project
+**/.settings
+/.classpath
 # CMake
 cmake-build-*/
 
diff --git a/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
index 1930bd7f..645d7d06 100644
--- a/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
+++ b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
@@ -32,10 +32,20 @@ public static class ToServer {
   @ApiModel("ExposureContactFromServer")
   @Data
   public static class FromServer {
-    private Patient.IdentityView source;
-    private Patient.IdentityView contact;
+    private ExposureContactDTO.ContactView source;
+    private ExposureContactDTO.ContactView contact;
 
     @JsonUnwrapped
     private ExposureContactDTO.Common common;
   }
+
+	@ApiModel("ExposureContactContactView")
+	@Data
+  public static class ContactView {
+		private String id;
+		private String firstName;
+		private String lastName;
+		private boolean infected;
+		private boolean inQuarantine;
+	}
 }
diff --git a/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java b/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
index 83fcb1a5..a50a8e70 100644
--- a/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
+++ b/server/src/main/java/de/coronavirus/imis/mapper/ExposureContactMapper.java
@@ -1,16 +1,30 @@
 package de.coronavirus.imis.mapper;
 
+import java.time.LocalDate;
+
 import de.coronavirus.imis.api.dto.ExposureContactDTO;
+import de.coronavirus.imis.domain.EventType;
 import de.coronavirus.imis.domain.ExposureContact;
+import de.coronavirus.imis.domain.Patient;
 import de.coronavirus.imis.mapper.PatientMapper;
+import de.coronavirus.imis.repositories.PatientRepository;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.MappingTarget;
+import org.springframework.beans.factory.annotation.Autowired;
 
-@Mapper(uses = PatientMapper.class)
+@Mapper(imports = {
+  EventType.class,
+  LocalDate.class
+})
 public abstract class ExposureContactMapper {
 
+  @Autowired
+  protected PatientRepository patientRepo;
+
   @Mapping(target = "id", source = "common.id")
+  @Mapping(target = "source", expression = "java( patientRepo.findById(dto.getSource()).orElse(null) )")
+  @Mapping(target = "contact", expression = "java( patientRepo.findById(dto.getContact()).orElse(null) )")
   @Mapping(target = "context", source = "common.context")
   @Mapping(target = "dateOfContact", source = "common.dateOfContact")
   @Mapping(target = "comment", source = "common.comment")
@@ -18,4 +32,8 @@ public abstract class ExposureContactMapper {
 
   @Mapping(target = "common", source = ".")
   public abstract ExposureContactDTO.FromServer toExposureContactDTO(ExposureContact contact);
+
+  @Mapping(target = "infected", expression = "java( patient.getPatientStatus() == EventType.TEST_FINISHED_POSITIVE )")
+  @Mapping(target = "inQuarantine", expression = "java( patient.getQuarantineUntil() != null && patient.getQuarantineUntil().isAfter(LocalDate.now()) )")
+  public abstract ExposureContactDTO.ContactView toContactView(Patient patient);
 }

From afa50afd080cec378018cac05322d18a4333dc88 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Thu, 30 Apr 2020 22:28:15 +0200
Subject: [PATCH 03/17] Support creation of new Patient records alongside
 exposure contact creation

---
 .../imis/api/dto/ExposureContactDTO.java      | 57 ++++++++++++++++---
 .../imis/domain/StringListConverter.java      |  6 +-
 2 files changed, 52 insertions(+), 11 deletions(-)

diff --git a/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
index 645d7d06..2f48c080 100644
--- a/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
+++ b/server/src/main/java/de/coronavirus/imis/api/dto/ExposureContactDTO.java
@@ -3,13 +3,23 @@
 import java.time.LocalDate;
 
 import com.fasterxml.jackson.annotation.JsonUnwrapped;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.util.StdConverter;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import io.swagger.annotations.ApiModel;
 import lombok.Data;
 import lombok.Getter;
 import lombok.Setter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
+import de.coronavirus.imis.api.dto.CreatePatientDTO;
 import de.coronavirus.imis.domain.Patient;
+import de.coronavirus.imis.services.PatientService;
 
+@Component
 public abstract class ExposureContactDTO {
   @Data
   public static class Common {
@@ -23,6 +33,7 @@ public static class Common {
   @Data
   public static class ToServer {
     private String source;
+    @JsonDeserialize(converter = ExOrNewContactConverter.class)
     private String contact;
 
     @JsonUnwrapped
@@ -39,13 +50,43 @@ public static class FromServer {
     private ExposureContactDTO.Common common;
   }
 
-	@ApiModel("ExposureContactContactView")
-	@Data
+  @ApiModel("ExposureContactContactView")
+  @Data
   public static class ContactView {
-		private String id;
-		private String firstName;
-		private String lastName;
-		private boolean infected;
-		private boolean inQuarantine;
-	}
+    private String id;
+    private String firstName;
+    private String lastName;
+    private boolean infected;
+    private boolean inQuarantine;
+  }
+
+
+  /**
+   * Allow exposure contacts to be specified either by ID to
+   * an existing patient, or data for a new Patient instance
+   */
+  @Component
+  public static class ExOrNewContactConverter
+    extends StdConverter<JsonNode, String> {
+
+    @Autowired
+    private PatientService patientService;
+
+    private ObjectMapper jsonMapper = new ObjectMapper();
+
+    public String convert(JsonNode in) {
+      if (in == null) {
+        return null;
+      } else if (in.isTextual()) {
+        return in.textValue();
+      } else {
+        try {
+          CreatePatientDTO newPatientDto = this.jsonMapper.treeToValue(in, CreatePatientDTO.class);
+          return this.patientService.addPatient(newPatientDto, true).getId();
+        } catch (JsonProcessingException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    }
+  }
 }
diff --git a/server/src/main/java/de/coronavirus/imis/domain/StringListConverter.java b/server/src/main/java/de/coronavirus/imis/domain/StringListConverter.java
index 28d82fef..aa7da6e6 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/StringListConverter.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/StringListConverter.java
@@ -11,11 +11,11 @@ public class StringListConverter implements AttributeConverter<List<String>, Str
 
 	@Override
 	public String convertToDatabaseColumn(List<String> stringList) {
-		return String.join(SPLIT_CHAR, stringList);
+		return stringList != null ? String.join(SPLIT_CHAR, stringList) : null;
 	}
 
 	@Override
 	public List<String> convertToEntityAttribute(String string) {
-		return Arrays.asList(string.split(SPLIT_CHAR));
+		return string != null ? Arrays.asList(string.split(SPLIT_CHAR)) : null;
 	}
-}
\ No newline at end of file
+}

From 4078524a8d767af478def6f7c4900f5b8afc90f9 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Fri, 1 May 2020 13:46:11 +0200
Subject: [PATCH 04/17] Update SwaggerApi.ts

---
 client/src/api/SwaggerApi.ts | 98 ++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)

diff --git a/client/src/api/SwaggerApi.ts b/client/src/api/SwaggerApi.ts
index a93e10bc..fff30ccd 100644
--- a/client/src/api/SwaggerApi.ts
+++ b/client/src/api/SwaggerApi.ts
@@ -116,6 +116,32 @@ export interface Doctor {
   zip?: string;
 }
 
+export interface ExposureContactContactView {
+  firstName?: string;
+  id?: string;
+  inQuarantine?: boolean;
+  infected?: boolean;
+  lastName?: string;
+}
+
+export interface ExposureContactFromServer {
+  comment?: string;
+  contact?: ExposureContactContactView;
+  context?: string;
+  dateOfContact?: string;
+  id?: number;
+  source?: ExposureContactContactView;
+}
+
+export interface ExposureContactToServer {
+  comment?: string;
+  contact?: string;
+  context?: string;
+  dateOfContact?: string;
+  id?: number;
+  source?: string;
+}
+
 export interface GrantedAuthority {
   authority?: string;
 }
@@ -686,6 +712,78 @@ export class Api<SecurityDataType = any> extends HttpClient<SecurityDataType> {
     addScheduledEventUsingPost: (dto: RequestLabTestDTO, params?: RequestParams) =>
       this.request<PatientEvent, any>(`/api/doctor/create_appointment`, "POST", params, dto, true),
 
+    /**
+     * @tags exposure-contact-controller
+     * @name createExposureContactUsingPOST
+     * @summary createExposureContact
+     * @request POST:/api/exposure-contacts
+     * @secure
+     */
+    createExposureContactUsingPost: (dto: ExposureContactToServer, params?: RequestParams) =>
+      this.request<ExposureContactFromServer, any>(`/api/exposure-contacts`, "POST", params, dto, true),
+
+    /**
+     * @tags exposure-contact-controller
+     * @name updateExposureContactUsingPUT
+     * @summary updateExposureContact
+     * @request PUT:/api/exposure-contacts
+     * @secure
+     */
+    updateExposureContactUsingPut: (contact: ExposureContactToServer, params?: RequestParams) =>
+      this.request<ExposureContactFromServer, any>(`/api/exposure-contacts`, "PUT", params, contact, true),
+
+    /**
+     * @tags exposure-contact-controller
+     * @name getExposureSourceContactForPatientUsingGET
+     * @summary getExposureSourceContactForPatient
+     * @request GET:/api/exposure-contacts/by-contact/{id}
+     * @secure
+     */
+    getExposureSourceContactForPatientUsingGet: (id: string, params?: RequestParams) =>
+      this.request<ExposureContactFromServer, any>(
+        `/api/exposure-contacts/by-contact/${id}`,
+        "GET",
+        params,
+        null,
+        true,
+      ),
+
+    /**
+     * @tags exposure-contact-controller
+     * @name getExposureContactsForPatientUsingGET
+     * @summary getExposureContactsForPatient
+     * @request GET:/api/exposure-contacts/by-source/{id}
+     * @secure
+     */
+    getExposureContactsForPatientUsingGet: (id: string, params?: RequestParams) =>
+      this.request<ExposureContactFromServer[], any>(
+        `/api/exposure-contacts/by-source/${id}`,
+        "GET",
+        params,
+        null,
+        true,
+      ),
+
+    /**
+     * @tags exposure-contact-controller
+     * @name getExposureContactUsingGET
+     * @summary getExposureContact
+     * @request GET:/api/exposure-contacts/{id}
+     * @secure
+     */
+    getExposureContactUsingGet: (id: number, params?: RequestParams) =>
+      this.request<ExposureContactFromServer, any>(`/api/exposure-contacts/${id}`, "GET", params, null, true),
+
+    /**
+     * @tags exposure-contact-controller
+     * @name removeExposureContactUsingDELETE
+     * @summary removeExposureContact
+     * @request DELETE:/api/exposure-contacts/{id}
+     * @secure
+     */
+    removeExposureContactUsingDelete: (id: number, params?: RequestParams) =>
+      this.request<any, any>(`/api/exposure-contacts/${id}`, "DELETE", params, null, true),
+
     /**
      * @tags institution-controller
      * @name createInstitutionUsingPOST

From 7d46d6976752c14d0f8f2bd68360bed19ff3ed48 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Fri, 1 May 2020 13:48:38 +0200
Subject: [PATCH 05/17] Starting refactoring of form control wrappers
 (DateInput and PatientInput)

---
 client/src/components/DateInput.vue    | 12 ++--
 client/src/components/PatientInput.vue | 83 +++++++++++++++++++-------
 2 files changed, 70 insertions(+), 25 deletions(-)

diff --git a/client/src/components/DateInput.vue b/client/src/components/DateInput.vue
index 8fcc85f3..85b1b875 100644
--- a/client/src/components/DateInput.vue
+++ b/client/src/components/DateInput.vue
@@ -1,13 +1,13 @@
 <template>
   <a-form-item :label="label">
     <a-date-picker
-      :disabled="disabled"
-      :format="dateFormat"
+      :format="$props.dateFormat"
       :open="dateOfBirthPickerOpen"
       @focus="datePickerFocused"
       @openChange="openChanged"
       placeholder="TT.MM.JJJJ (z.B. 28.02.1986)"
       style="width: 100%"
+      v-bind="$attrs"
       v-decorator="decorator"
     />
   </a-form-item>
@@ -27,17 +27,19 @@ import Vue from 'vue'
 export interface State {
   dateOfBirthPickerOpen: boolean;
   wasJustFocused: boolean;
-  dateFormat: string;
 }
 
 export default Vue.extend({
   name: 'LaboratoryInput',
-  props: ['decorator', 'label', 'disabled'],
+  props: {
+    label: { default: undefined },
+    dateFormat: { default: 'DD.MM.YYYY' },
+    decorator: { default: undefined },
+  },
   data(): State {
     return {
       dateOfBirthPickerOpen: false,
       wasJustFocused: false,
-      dateFormat: 'DD.MM.YYYY',
     }
   },
   methods: {
diff --git a/client/src/components/PatientInput.vue b/client/src/components/PatientInput.vue
index cab2af0b..adc80fd0 100644
--- a/client/src/components/PatientInput.vue
+++ b/client/src/components/PatientInput.vue
@@ -1,22 +1,32 @@
 <template>
-  <a-form-item :label="label">
-    <a-auto-complete :defaultActiveFirstOption="false" @search="handleSearch" @select="emitSelection"
-                     placeholder="Suche über ID, Name, Telefon, Mail" v-decorator="validation">
-      <template slot="dataSource">
-        <a-select-option :key="patient.id" v-for="patient in result">
-          {{patient.firstName}} {{patient.lastName}} ({{patient.id}})
-        </a-select-option>
-      </template>
-    </a-auto-complete>
-  </a-form-item>
+  <a-select ref="input" v-bind="$attrs" v-on="externListeners"
+                   :defaultActiveFirstOption="false"
+                   :placeholder="placeholder"
+                   :showSearch="true"
+                   :showArrow="false"
+                   :filterOption="false"
+                   :value="value"
+                   @search="handleSearch">
+    <a-select-option v-for="entry in result"
+      :key="entry.value">
+      {{ entry.label }}
+    </a-select-option>
+  </a-select>
 </template>
 
 <script lang="ts">
-
 import Api from '@/api'
 import Vue from 'vue'
+import { Select } from 'ant-design-vue'
 import { Patient } from '@/api/SwaggerApi'
 
+declare interface State {
+  result: {
+    label?: string;
+    value?: string;
+  }[];
+}
+
 /**
  * Autocomplete for Patients
  *
@@ -24,19 +34,52 @@ import { Patient } from '@/api/SwaggerApi'
  * - validation: put in v-decorator object
  */
 
-interface State {
-  result: Patient[];
-}
-
 export default Vue.extend({
   name: 'PatientInput',
-  props: ['validation', 'label', 'form'],
+  inheritAttrs: false,
+  props: {
+    placeholder: { default: 'Suche über ID, Name, Telefon, Mail' },
+    value: { default: '' },
+  },
+  model: {
+    prop: 'value',
+    event: 'change',
+  },
+  inject: {
+    FormContext: { default: () => ({}) },
+  },
   data(): State {
     return {
       result: [],
     }
   },
+  computed: {
+    externListeners() {
+      const { search, ...listeners } = this.$listeners
+      return listeners
+    },
+  },
+  watch: {
+    value() {
+      const hasProp = (obj: Record<string, any>, prop: string): boolean => Object.prototype.hasOwnProperty.call(obj, prop)
+      if (typeof this.value === 'object' && hasProp(this.value, 'id')) {
+        const patient = this.value as Patient
+        this.result = [{
+          label: this.getPatientLabel(patient),
+          value: patient.id,
+        }]
+        if (hasProp(this.$attrs, 'data-__meta')) {
+          this.FormContext.form.setFieldsValue({
+            [this.$attrs['data-__meta'].name]: patient.id,
+          })
+        }
+      }
+    },
+  },
   methods: {
+    getPatientLabel(patientData: Patient) {
+      return `${patientData.firstName} ${patientData.lastName} (${patientData.id})`
+    },
     async handleSearch(value: string) {
       let result: Patient[]
       if (!value || value.length < 2) {
@@ -50,10 +93,10 @@ export default Vue.extend({
           orderBy: 'lastName',
         })
       }
-      this.result = result
-    },
-    emitSelection(value: string) {
-      this.$emit('select', value)
+      this.result = result.map((patient: Patient) => ({
+        label: this.getPatientLabel(patient),
+        value: patient.id,
+      }))
     },
   },
 })

From bfdf6880a19141153a9d2957c740be2c2ef61a8f Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Fri, 1 May 2020 18:10:27 +0200
Subject: [PATCH 06/17] Add client-side contact person display and management,
 currently restricted to existing patients;

this commit additionally includes a rework and helper mixins for form components and form control groups, which
allow for easier implementation of custom input wrappers that can be used like their wrapped components, as well
as form component group components allowing custom keys for the contained components, key prefixing and
get/setFieldsValue support
---
 client/src/components/DateInput.vue           |  38 ++--
 client/src/components/EditExposureContact.vue | 141 +++++++++++++
 client/src/components/PatientInput.vue        |  34 +--
 client/src/components/PatientStammdaten.vue   |  17 +-
 client/src/util/forms.ts                      | 195 ++++++++++++++++++
 client/src/util/mapping.ts                    |  27 +++
 client/src/views/PatientDetails.vue           | 193 ++++++++++++++++-
 client/src/views/RegisterTest.vue             |  16 +-
 8 files changed, 609 insertions(+), 52 deletions(-)
 create mode 100644 client/src/components/EditExposureContact.vue
 create mode 100644 client/src/util/forms.ts
 create mode 100644 client/src/util/mapping.ts

diff --git a/client/src/components/DateInput.vue b/client/src/components/DateInput.vue
index 85b1b875..a85b2c75 100644
--- a/client/src/components/DateInput.vue
+++ b/client/src/components/DateInput.vue
@@ -1,21 +1,19 @@
 <template>
-  <a-form-item :label="label">
-    <a-date-picker
-      :format="$props.dateFormat"
-      :open="dateOfBirthPickerOpen"
-      @focus="datePickerFocused"
-      @openChange="openChanged"
-      placeholder="TT.MM.JJJJ (z.B. 28.02.1986)"
-      style="width: 100%"
-      v-bind="$attrs"
-      v-decorator="decorator"
-    />
-  </a-form-item>
+  <a-date-picker
+    v-bind="$attrs"
+    v-on="$listeners"
+    :value="value"
+    :format="format"
+    :open="open || dateOfBirthPickerOpen"
+    @focus="datePickerFocused"
+    @openChange="openChanged"
+    :placeholder="placeholder"
+  />
 </template>
 
 <script lang="ts">
-
 import Vue from 'vue'
+import { FormControlMixin } from '@/util/forms'
 
 /**
  * Input that supports 1d and 2d Barcodes
@@ -30,11 +28,17 @@ export interface State {
 }
 
 export default Vue.extend({
-  name: 'LaboratoryInput',
+  name: 'DateInput',
+  mixins: [FormControlMixin],
+  model: {
+    prop: 'value',
+    event: 'change',
+  },
   props: {
-    label: { default: undefined },
-    dateFormat: { default: 'DD.MM.YYYY' },
-    decorator: { default: undefined },
+    value: { default: undefined },
+    open: { default: false },
+    placeholder: { default: 'TT.MM.JJJJ (z.B. 28.02.1986)' },
+    format: { default: 'DD.MM.YYYY' },
   },
   data(): State {
     return {
diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
new file mode 100644
index 00000000..f0749a30
--- /dev/null
+++ b/client/src/components/EditExposureContact.vue
@@ -0,0 +1,141 @@
+<template>
+  <div class="edit-exposure-contact">
+    <a-form-item style="display: none;"
+      :selfUpdate="true">
+      <a-input type="hidden"
+        v-decorator="[ formInputKey('id') ]"/>
+    </a-form-item>
+    <a-row class="patients-flex">
+      <!-- Originating and Contact Names -->
+      <a-form-item
+        :style="`display: ${$props.showOriginatorPatient ? 'unset' : 'none'}`"
+        label="Ursprungspatient"
+        class="patient-input">
+        <patient-input
+          :disabled="$props.disableOriginatorPatient"
+          v-decorator="[ formInputKey('source'), {
+              rules: [
+                { required: true, message: 'Bitte Ursprungspatienten angeben' },
+              ],
+          }]"/>
+      </a-form-item>
+      <a-icon
+        v-if="$props.showOriginatorPatient && $props.showContactPatient"
+        type="swap"/>
+      <a-form-item
+        :style="`display: ${$props.showContactPatient ? 'unset' : 'none'}`"
+        label="Kontaktperson"
+        class="patient-input">
+        <patient-input
+          :disabled="$props.disableContactPatient"
+          v-decorator="[ formInputKey('contact'), {
+              rules: [
+                { required: true, message: 'Bitte Kontaktperson angeben' },
+                /* {
+                  validator: (value) => {
+                    const sourceKey = formInputKey('source')
+                    if (value === getData(sourceKey)[sourceKey]) throw new Error()
+                  },
+                  message: 'Ursprungsperson und Kontaktperson dürfen nicht übereinstimmen!'
+                }, */
+              ],
+          }]"/>
+      </a-form-item>
+    </a-row>
+    <a-row>
+      <!-- When and How -->
+      <a-col :md="12" :sm="24">
+        <a-form-item label="Datum des Kontakts">
+          <date-input
+            v-decorator="[ formInputKey('dateOfContact'), {
+              rules: [
+                { required: true, message: 'Bitte ein gültiges Datum angeben' },
+              ],
+            }]"/>
+        </a-form-item>
+      </a-col>
+      <a-col :md="12" :sm="24">
+        <a-form-item label="Umgebung / Kontext"
+          :selfUpdate="true">
+          <a-auto-complete
+            :dataSource="contexts"
+            :filterOption="false"
+            v-decorator="[ formInputKey('context'), {
+              rules: [
+                { required: true, message: 'Bitte den Umstand des Kontakts angeben' }
+              ]
+            }]"/>
+        </a-form-item>
+      </a-col>
+    </a-row>
+    <a-row>
+      <!-- Comment Space -->
+      <a-form-item label="Sonstiges / Kommentar"
+        :selfUpdate="true">
+        <a-textarea
+          v-decorator="[ formInputKey('comment'), {
+            rules: [],
+          }]"/>
+      </a-form-item>
+    </a-row>
+  </div>
+</template>
+
+<script lang="ts">
+import Vue from 'vue'
+import Api from '@/api'
+import moment from 'moment'
+
+import DateInput from '@/components/DateInput.vue'
+import PatientInput from '@/components/PatientInput.vue'
+import { FormGroupMixin } from '@/util/forms.ts'
+
+const exposureContexts = [
+  'Haushaltskontakt',
+  'Berufskontakt',
+  'Kontakt in Gemeinschaftseinrichtung',
+]
+
+export default Vue.extend({
+  name: 'EditExposureFormGroup',
+  mixins: [FormGroupMixin],
+  components: {
+    DateInput,
+    PatientInput,
+  },
+  inputKeys: ['id', 'source', 'contact', 'dateOfContact', 'context', 'comment'],
+  props: {
+    showOriginatorPatient: { default: true },
+    showContactPatient: { default: true },
+    disableOriginatorPatient: { default: false },
+    disableContactPatient: { default: false },
+  },
+  data() {
+    return {
+      contexts: exposureContexts,
+    }
+  },
+  methods: {
+  },
+} as any)
+</script>
+
+<style lang="scss">
+  .edit-exposure-contact {
+    .patients-flex {
+      display: flex;
+      flex-flow: row wrap;
+      align-items: center;
+      align-content: center;
+      justify-content: center;
+    }
+
+    .patients-flex > * {
+      flex: 1 1;
+    }
+
+    .patients-flex > .patient-input {
+      min-width: 47%;
+    }
+  }
+</style>
diff --git a/client/src/components/PatientInput.vue b/client/src/components/PatientInput.vue
index adc80fd0..e321c478 100644
--- a/client/src/components/PatientInput.vue
+++ b/client/src/components/PatientInput.vue
@@ -19,6 +19,7 @@ import Api from '@/api'
 import Vue from 'vue'
 import { Select } from 'ant-design-vue'
 import { Patient } from '@/api/SwaggerApi'
+import { FormControlMixin } from '@/util/forms'
 
 declare interface State {
   result: {
@@ -37,6 +38,7 @@ declare interface State {
 export default Vue.extend({
   name: 'PatientInput',
   inheritAttrs: false,
+  mixins: [FormControlMixin],
   props: {
     placeholder: { default: 'Suche über ID, Name, Telefon, Mail' },
     value: { default: '' },
@@ -45,6 +47,21 @@ export default Vue.extend({
     prop: 'value',
     event: 'change',
   },
+  fieldValueConvert(val: any): string {
+    const hasProp = (obj: Record<string, any>, prop: string): boolean =>
+      Object.prototype.hasOwnProperty.call(obj, prop)
+
+    if (typeof val === 'object' && hasProp(val, 'id')) {
+      const patient = val as Patient
+      this.result = [{
+        label: this.getPatientLabel(patient),
+        value: patient.id,
+      }]
+      return patient.id
+    } else {
+      return val
+    }
+  },
   inject: {
     FormContext: { default: () => ({}) },
   },
@@ -59,23 +76,6 @@ export default Vue.extend({
       return listeners
     },
   },
-  watch: {
-    value() {
-      const hasProp = (obj: Record<string, any>, prop: string): boolean => Object.prototype.hasOwnProperty.call(obj, prop)
-      if (typeof this.value === 'object' && hasProp(this.value, 'id')) {
-        const patient = this.value as Patient
-        this.result = [{
-          label: this.getPatientLabel(patient),
-          value: patient.id,
-        }]
-        if (hasProp(this.$attrs, 'data-__meta')) {
-          this.FormContext.form.setFieldsValue({
-            [this.$attrs['data-__meta'].name]: patient.id,
-          })
-        }
-      }
-    },
-  },
   methods: {
     getPatientLabel(patientData: Patient) {
       return `${patientData.firstName} ${patientData.lastName} (${patientData.id})`
diff --git a/client/src/components/PatientStammdaten.vue b/client/src/components/PatientStammdaten.vue
index 910f36af..e1a2f97b 100644
--- a/client/src/components/PatientStammdaten.vue
+++ b/client/src/components/PatientStammdaten.vue
@@ -53,10 +53,12 @@
           </a-form-item>
         </a-col>
         <a-col :lg="12" :sm="24">
-          <DateInput :decorator="['dateOfBirth', { rules: [{
-                        required: true,
-                        message: 'Bitte Geburtsdatum eingeben',
-                      }], initialValue: initialDateOfBirth}]" label="Geburtsdatum" />
+          <a-form-item label="Geburtsdatum">
+            <DateInput v-decorator="['dateOfBirth', { rules: [{
+                          required: true,
+                          message: 'Bitte Geburtsdatum eingeben',
+                        }], initialValue: initialDateOfBirth}]" />
+          </a-form-item>
         </a-col>
       </a-row>
 
@@ -85,9 +87,10 @@
           </a-form-item>
         </a-col>
         <a-col :lg="12" :sm="24">
-          <DateInput :decorator="['dateOfDeath', {initialValue: initialDateOfDeath}]"
-                     :disabled="!showDateOfDeath"
-                     label="Todesdatum" />
+          <a-form-item label="Todesdatum">
+            <DateInput v-decorator="['dateOfDeath', {initialValue: initialDateOfDeath}]"
+                       :disabled="!showDateOfDeath" />
+          </a-form-item>
         </a-col>
       </a-row>
 
diff --git a/client/src/util/forms.ts b/client/src/util/forms.ts
new file mode 100644
index 00000000..16d91afa
--- /dev/null
+++ b/client/src/util/forms.ts
@@ -0,0 +1,195 @@
+// Realise camelCase prefixing, whereas the prefixed name starts with capital
+function prefixed(name: string, prefix?: string): string {
+  if (!prefix) {
+    return name
+  } else {
+    return prefix + name.charAt(0).toUpperCase() + name.substring(1)
+  }
+}
+function prefixedKeysObject(keys: {[x: string]: any}, prefix?: string): {[x: string]: any} {
+  return Object.fromEntries((Object.entries(keys) as [string, string][]).map(
+    (entry: [string, string]) => [prefixed(entry[0], prefix), entry[1]],
+  ))
+}
+function prefixedKeysArray(keys: string[], prefix?: string): string[] {
+  return keys.map((key: string) => prefixed(key, prefix))
+}
+
+declare interface FormGroupMixinType {
+    $options: {
+      name: string;
+      inputKeys: string[];
+    };
+    $props: {
+      inputKeyPrefix?: string;
+      inputKeys: { [x: string]: string };
+    };
+    $watch: any;
+    $forceUpdate: () => void;
+
+    formInputKey: (this: FormGroupMixinType, key: string) => string;
+    FormContext: any;
+
+    prefixedKeysObject: (this: FormGroupMixinType, keys: {[x: string]: any}, prefix?: string) => {[x: string]: any};
+    prefixedKeysArray: (this: FormGroupMixinType, keys: string[], prefix?: string) => string[];
+}
+
+export const FormGroupMixin = {
+  props: {
+    inputKeyPrefix: {
+      default: undefined,
+    },
+    inputKeys: {
+      default: () => ({}),
+    },
+  },
+  inject: {
+    FormContext: { default: () => ({}) },
+  },
+  mounted(this: FormGroupMixinType) {
+    // Make sure all form items use selfUpdate; this is crucial for form items
+    // in the group to be re-rendered correctly when new values are set
+    this.$options.inputKeys.forEach((key: string) => {
+      if (!this.FormContext.form.formItems[this.formInputKey(key)].itemSelfUpdate) {
+        console.error(`[ ${this.$options.name} ]: ` +
+          `\`itemSelfUpdate\` is not enabled for form item of \`${key}\`. ` +
+          'This may lead to contents not being re-rendered when their ' +
+          'value is modified by calling `setFieldsValue` on its ' +
+          'containing form. To fix this, add `:selfUpdate="true"` to ' +
+          `the \`a-form-item\` component containing the \`${key}\` control ` +
+          'or add `:selfUpdate="true"` to the root `a-form` element.',
+        )
+      }
+    })
+  },
+  methods: {
+    formInputKey(this: FormGroupMixinType, key: string): string {
+      const propKeys = this.$props.inputKeys
+      return Object.prototype.hasOwnProperty.call(propKeys, key)
+        ? propKeys[key]
+        : prefixed(key, this.$props.inputKeyPrefix)
+    },
+    prefixedKeysObject(this: FormGroupMixinType, keys: {[x: string]: any}): {[x: string]: any} {
+      return prefixedKeysObject(keys, this.$props.inputKeyPrefix)
+    },
+    prefixedKeysArray(this: FormGroupMixinType, keys: string[]): string[] {
+      return prefixedKeysArray(keys, this.$props.inputKeyPrefix)
+    },
+    setData(this: FormGroupMixinType, data: {[x: string]: any}, usesPrefixedKeys: boolean | undefined) {
+      if (!usesPrefixedKeys) {
+        data = this.prefixedKeysObject(data)
+      }
+      if (data) {
+        const prefixedInputKeys = prefixedKeysArray(this.$options.inputKeys)
+        data = Object.fromEntries(Object.entries(data).filter(
+          (value: [string, any]) => prefixedInputKeys.includes(value[0]),
+        ))
+      }
+      this.FormContext.form.setFieldsValue(data)
+    },
+    getData(this: FormGroupMixinType, fieldNames?: string[], usesPrefixedKeys?: boolean): {[x: string]: any} {
+      if (fieldNames !== undefined && !usesPrefixedKeys) {
+        fieldNames = this.prefixedKeysArray(fieldNames)
+      }
+
+      const permittedFieldNames = prefixedKeysArray(this.$options.inputKeys)
+      if (fieldNames === undefined) {
+        fieldNames = permittedFieldNames
+      } else {
+        fieldNames = fieldNames.filter(
+          (fieldName: string) => permittedFieldNames.includes(fieldName),
+        )
+      }
+      return this.FormContext.form.getFieldsValue(fieldNames)
+    },
+  },
+}
+
+declare interface FormControlMixinType {
+  $options: {
+    fieldValueConvert?: (val: any) => any;
+    forwardEvents?: string[];
+    model?: {
+      prop?: string;
+      event?: string;
+    };
+  };
+  $attrs: {
+    'data-__field'?: {
+      name: string;
+      value: any;
+    };
+  };
+  $emit: (event: string, param?: any) => void;
+  $watch: (expr: string, cb: (val: any) => void) => void;
+
+  FormContext?: {
+    form: {
+      setFieldsValue: (fields: { [x: string]: any }) => void;
+    };
+  };
+
+  __convValue: any;
+  fieldName: string | null;
+  isDecoratedFormField(): boolean;
+  getOwnValue(): any;
+  setOwnValue(val: any): void;
+}
+
+export const FormControlMixin = {
+  inject: {
+    FormContext: { default: null },
+  },
+  computed: {
+    fieldName(this: FormControlMixinType): string | null {
+      if (this.FormContext && this.$attrs['data-__field']) {
+        return this.$attrs['data-__field'].name
+      } else {
+        return null
+      }
+    },
+  },
+  data() {
+    return {
+      __convValue: undefined,
+    }
+  },
+  created(this: FormControlMixinType) {
+    if (this.$options.fieldValueConvert) {
+      const valueProp = (this.$options.model && this.$options.model.prop)
+        ? this.$options.model.prop
+        : 'value'
+
+      this.$watch(valueProp, (value: any) => {
+        if (this.__convValue === value) {
+          // Value has already been converted
+          this.__convValue = undefined
+        } else {
+          const newValue = this.$options.fieldValueConvert?.call(this, value)
+          if (newValue !== value) {
+            this.__convValue = newValue
+            this.setOwnValue(newValue)
+          }
+        }
+      })
+    }
+  },
+  methods: {
+    isDecoratedFormField(this: FormControlMixinType): boolean {
+      return !!(this.FormContext && this.$attrs['data-__field'])
+    },
+    setOwnValue(this: FormControlMixinType, value: any) {
+      const eventType = (this.$options.model && this.$options.model.event)
+        ? this.$options.model.event
+        : 'change'
+
+      this.$emit(eventType, value)
+    },
+    getOwnValue(this: FormControlMixinType) {
+      const valueProp = (this.$options.model && this.$options.model.prop)
+        ? this.$options.model.prop
+        : 'value'
+      return (this as {[x: string]: any})[valueProp]
+    },
+  },
+}
diff --git a/client/src/util/mapping.ts b/client/src/util/mapping.ts
new file mode 100644
index 00000000..0dffd723
--- /dev/null
+++ b/client/src/util/mapping.ts
@@ -0,0 +1,27 @@
+export declare interface MapperDefEntry {
+  transform: (x: any) => any;
+}
+export declare type MapperDef = { [x: string]: ((x: any) => any | Partial<MapperDefEntry>) };
+
+export function map(object: {[x: string]: any}, mapperDef: MapperDef) {
+  return Object.fromEntries(Object.entries(object).map(
+    (entry: [any, any]) => {
+      let [key, val] = entry
+      let mapperEntry: any = mapperDef[key]
+
+      if (mapperEntry) {
+        if (typeof mapperEntry === 'function') {
+          mapperEntry = { transform: mapperEntry as (value: any) => any }
+        }
+
+        if (Object.prototype.hasOwnProperty.call(mapperEntry, 'transform')) {
+          val = mapperEntry.transform(val)
+        }
+
+        entry = [key, val]
+      }
+
+      return entry
+    },
+  ))
+}
diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index f9677685..36d0fdc2 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -235,6 +235,71 @@
             </a-timeline>
           </a-card>
         </a-tab-pane>
+        <a-tab-pane
+          forceRender
+          key="3"
+          tab="Kontaktpersonen">
+          <!-- exposed contacts -->
+          <a-card>
+            <div slot="extra">
+              <a-button
+                icon="plus"
+                @click="addExposureContact">
+                Hinzufügen
+              </a-button>
+            </div>
+
+            <a-table
+              :columns="columnsExposureContacts"
+              :dataSource="exposureContacts"
+              class="imis-table-no-pagination"
+              :rowKey="contact => contact.contact.id"
+              :loading="exposureContactsLoading"
+              :customRow="contact => ({
+                on: { dblclick: () => showExposureContact(contact.id) }
+              })">
+              <template slot="dateOfContact" slot-scope="contact">
+                {{ moment(contact.dateOfContact).format('DD.MM.YYYY') }}
+              </template>
+              <template slot="infectionState" slot-scope="contact">
+                <span v-if="contact.contact.infected"
+                  style="color: red;">
+                  Infiziert
+                </span>
+                <span v-else>
+                  Unbekannt
+                </span>
+              </template>
+              <template slot="quarantineState" slot-scope="contact">
+                <span v-if="contact.contact.inQuarantine">
+                  In Quarantäne
+                </span>
+                <span v-else
+                  :style="`color: ${contact.contact.infected ? 'red' : 'unset'};`">
+                  Keine Quarantäne
+                </span>
+              </template>
+              <template slot="actions" slot-scope="contact">
+                <a-button ghost
+                  icon="close"
+                  type="danger"
+                  title="Entfernen"
+                  @click="removeExposureContact(contact.id)"/>
+              </template>
+            </a-table>
+          </a-card>
+          <a-modal title="Kontaktperson bearbeiten"
+            ref="exposureContactModal"
+            :visible="!!exposureContactInEditing"
+            @ok="persistExposureContact()
+              .then((success) => { if (success) exposureContactInEditing = null })"
+            @cancel="exposureContactInEditing = null">
+            <a-form :form="exposureContactForm" :selfUpdate="true">
+              <EditExposureContact
+                :disableOriginatorPatient="true"/>
+            </a-form>
+          </a-modal>
+        </a-tab-pane>
       </a-tabs>
     </div>
   </div>
@@ -242,9 +307,9 @@
 
 <script lang="ts">
 import Vue from 'vue'
-import moment from 'moment'
+import moment, { Moment } from 'moment'
 import Api from '@/api'
-import { LabTest, Patient, Timestamp } from '@/api/SwaggerApi'
+import { LabTest, Patient, Timestamp, ExposureContactFromServer } from '@/api/SwaggerApi'
 import { patientMapper } from '@/store/modules/patients.module'
 import { EventTypeItem, eventTypes, testResults, TestResultType } from '@/models/event-types'
 import { SYMPTOMS } from '@/models/symptoms'
@@ -252,6 +317,8 @@ import { PRE_ILLNESSES } from '@/models/pre-illnesses'
 import { Column } from 'ant-design-vue/types/table/column'
 import { TestTypeItem, testTypes } from '@/models/test-types'
 import ChangePatientStammdatenForm from '@/components/ChangePatientStammdatenForm.vue'
+import EditExposureContact from '@/components/EditExposureContact.vue'
+import { map } from '@/util/mapping'
 
 const columnsTests: Partial<Column>[] = [
   {
@@ -279,8 +346,55 @@ const columnsTests: Partial<Column>[] = [
   },
 ]
 
+const columnsExposureContacts: Partial<Column>[] = [
+  {
+    title: 'Nachname',
+    key: 'lastName',
+    dataIndex: 'contact.lastName',
+  },
+  {
+    title: 'Vorname',
+    key: 'firstName',
+    dataIndex: 'contact.firstName',
+  },
+  {
+    title: 'Datum des Kontakts',
+    key: 'dateOfContact',
+    scopedSlots: {
+      customRender: 'dateOfContact',
+    },
+  },
+  {
+    title: 'Infektionsstatus',
+    key: 'infected',
+    scopedSlots: {
+      customRender: 'infectionState',
+    },
+  },
+  {
+    title: 'Quarantänestatus',
+    key: 'quarantine',
+    scopedSlots: {
+      customRender: 'quarantineState',
+    },
+  },
+  {
+    title: 'Aktionen',
+    key: 'actions',
+    width: '70pt',
+    align: 'center',
+    scopedSlots: {
+      customRender: 'actions',
+    },
+  },
+]
+
 interface State {
   patient: undefined | Patient;
+  exposureContacts: ExposureContactFromServer[];
+  exposureContactsLoading: boolean;
+  exposureContactForm: any;
+  exposureContactInEditing: any;
   patientStatus: EventTypeItem | undefined;
   eventTypes: any[];
   symptoms: string[];
@@ -290,6 +404,7 @@ interface State {
   gender: string;
   tests: LabTest[];
   columnsTests: Partial<Column>[];
+  columnsExposureContacts: Partial<Column>[];
   testResults: TestResultType[];
   testTypes: TestTypeItem[];
 }
@@ -298,6 +413,7 @@ export default Vue.extend({
   name: 'PatientDetails',
   components: {
     ChangePatientStammdatenForm,
+    EditExposureContact,
   },
   computed: {
     ...patientMapper.mapGetters({
@@ -307,11 +423,20 @@ export default Vue.extend({
 
   async created() {
     this.loadData()
+    this.exposureContactForm = this.$form.createForm(
+      this.$refs.exposureContactModal as Vue, {
+        name: 'exposure-contact',
+      },
+    )
   },
 
   data(): State {
     return {
       patient: undefined,
+      exposureContacts: [],
+      exposureContactsLoading: false,
+      exposureContactForm: undefined,
+      exposureContactInEditing: null,
       patientStatus: undefined,
       eventTypes: eventTypes,
       testResults: testResults,
@@ -323,6 +448,7 @@ export default Vue.extend({
       gender: '',
       tests: [],
       columnsTests,
+      columnsExposureContacts,
     }
   },
 
@@ -337,7 +463,8 @@ export default Vue.extend({
       setPatient: 'setPatient',
     }),
     async loadData() {
-      console.log('loading')
+      this.exposureContactsLoading = true
+
       // Load Patient
       const patientId = this.$route.params.id
       this.patient = this.patientById(this.$route.params.id)
@@ -363,6 +490,10 @@ export default Vue.extend({
 
       // Tests
       this.tests = await Api.getLabTestForPatientUsingGet(patientId)
+
+      // Retrieve exposure contacts data
+      this.exposureContacts = await Api.getExposureContactsForPatientUsingGet(patientId)
+      this.exposureContactsLoading = false
     },
     timelineColor(eventType: any) {
       switch (eventType) {
@@ -413,6 +544,62 @@ export default Vue.extend({
         })
       }
     },
+    addExposureContact() {
+      const patientId = this.patient?.id
+
+      this.exposureContactInEditing = {}
+
+      Vue.nextTick(() => {
+        this.exposureContactForm.resetFields()
+        this.exposureContactForm.setFieldsValue({
+          source: this.patient,
+        })
+      })
+    },
+    showExposureContact(contactId: number) {
+      const contact = this.exposureContacts.find((contact: any) => contact.id === contactId)
+
+      this.exposureContactInEditing = contact
+
+      Vue.nextTick(() => {
+        this.exposureContactForm.setFieldsValue(map(contact as {[x: string]: any}, {
+          // source: patient => patient.id,
+          // contact: patient => patient.id,
+          dateOfContact: moment,
+        }))
+      })
+    },
+    persistExposureContact(): Promise<boolean> {
+      const stringFromMoment = (value: Moment): string => value.format('YYYY-MM-DD')
+
+      return new Promise((resolve: () => void) => {
+        this.exposureContactForm.validateFields(async(err: Error[], values: {[x: string]: any}) => {
+          if (err) {
+            resolve(false)
+            return
+          }
+
+          // Convert values to transport format
+          values = map(values, {
+            id: parseInt,
+            dateOfContact: stringFromMoment,
+          })
+
+          if (values.id) {
+            Object.assign(this.exposureContactInEditing, await Api.updateExposureContactUsingPut(values))
+          } else {
+            this.exposureContacts.push(await Api.createExposureContactUsingPost(values))
+          }
+
+          resolve(true)
+        })
+      })
+    },
+    async removeExposureContact(contactId: number) {
+      await Api.removeExposureContactUsingDelete(contactId)
+      this.exposureContacts = this.exposureContacts.filter(contact => contact.id !== contactId)
+    },
+    moment,
   },
 })
 </script>
diff --git a/client/src/views/RegisterTest.vue b/client/src/views/RegisterTest.vue
index d4eac1ff..d641b8fb 100644
--- a/client/src/views/RegisterTest.vue
+++ b/client/src/views/RegisterTest.vue
@@ -17,14 +17,14 @@
         label="Labor"
       />
 
-      <PatientInput
-        :form="form"
-        :validation="['patientId',{ rules: [{
-          required: true,
-          message: 'Bitte geben Sie die Patienten-ID ein.'
-        }]}]"
-        label="Patienten-ID"
-      />
+      <a-form-item label="Patienten-ID">
+        <PatientInput
+          v-decorator="['patientId',{ rules: [{
+            required: true,
+            message: 'Bitte geben Sie die Patienten-ID ein.'
+          }]}]"
+        />
+      </a-form-item>
 
       <!-- Test ID -->
       <a-form-item label="Test-ID">

From a8907259e03e64c46fab81f92f6705df03391ef3 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Sun, 3 May 2020 16:08:17 +0200
Subject: [PATCH 07/17] Fix Typing and add  prop to form items of  component

---
 client/package.json                           |   1 +
 client/src/components/DateInput.vue           |   3 +-
 client/src/components/EditExposureContact.vue |   9 +-
 client/src/components/PatientInput.vue        |   6 +-
 client/src/util/forms.ts                      | 102 +++++++++++-------
 client/src/views/PatientDetails.vue           |   2 +-
 client/yarn.lock                              |   5 +
 7 files changed, 81 insertions(+), 47 deletions(-)

diff --git a/client/package.json b/client/package.json
index 3b837a6d..8fff87ed 100644
--- a/client/package.json
+++ b/client/package.json
@@ -19,6 +19,7 @@
     "register-service-worker": "^1.6.2",
     "vue": "^2.6.11",
     "vue-router": "^3.1.5",
+    "vue-typed-mixins": "^0.2.0",
     "vuex": "^3.1.2",
     "vuex-smart-module": "^0.3.4"
   },
diff --git a/client/src/components/DateInput.vue b/client/src/components/DateInput.vue
index a85b2c75..a36a4e31 100644
--- a/client/src/components/DateInput.vue
+++ b/client/src/components/DateInput.vue
@@ -13,6 +13,7 @@
 
 <script lang="ts">
 import Vue from 'vue'
+import mixins from 'vue-typed-mixins'
 import { FormControlMixin } from '@/util/forms'
 
 /**
@@ -27,7 +28,7 @@ export interface State {
   wasJustFocused: boolean;
 }
 
-export default Vue.extend({
+export default mixins(FormControlMixin).extend({
   name: 'DateInput',
   mixins: [FormControlMixin],
   model: {
diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
index f0749a30..7d2973a8 100644
--- a/client/src/components/EditExposureContact.vue
+++ b/client/src/components/EditExposureContact.vue
@@ -9,6 +9,7 @@
       <!-- Originating and Contact Names -->
       <a-form-item
         :style="`display: ${$props.showOriginatorPatient ? 'unset' : 'none'}`"
+        :selfUpdate="true"
         label="Ursprungspatient"
         class="patient-input">
         <patient-input
@@ -24,6 +25,7 @@
         type="swap"/>
       <a-form-item
         :style="`display: ${$props.showContactPatient ? 'unset' : 'none'}`"
+        :selfUpdate="true"
         label="Kontaktperson"
         class="patient-input">
         <patient-input
@@ -45,7 +47,8 @@
     <a-row>
       <!-- When and How -->
       <a-col :md="12" :sm="24">
-        <a-form-item label="Datum des Kontakts">
+        <a-form-item label="Datum des Kontakts"
+          :selfUpdate="true">
           <date-input
             v-decorator="[ formInputKey('dateOfContact'), {
               rules: [
@@ -83,6 +86,7 @@
 
 <script lang="ts">
 import Vue from 'vue'
+import mixins from 'vue-typed-mixins'
 import Api from '@/api'
 import moment from 'moment'
 
@@ -96,9 +100,8 @@ const exposureContexts = [
   'Kontakt in Gemeinschaftseinrichtung',
 ]
 
-export default Vue.extend({
+export default mixins(FormGroupMixin).extend({
   name: 'EditExposureFormGroup',
-  mixins: [FormGroupMixin],
   components: {
     DateInput,
     PatientInput,
diff --git a/client/src/components/PatientInput.vue b/client/src/components/PatientInput.vue
index e321c478..abd7bd6f 100644
--- a/client/src/components/PatientInput.vue
+++ b/client/src/components/PatientInput.vue
@@ -17,6 +17,7 @@
 <script lang="ts">
 import Api from '@/api'
 import Vue from 'vue'
+import mixins from 'vue-typed-mixins'
 import { Select } from 'ant-design-vue'
 import { Patient } from '@/api/SwaggerApi'
 import { FormControlMixin } from '@/util/forms'
@@ -35,10 +36,9 @@ declare interface State {
  * - validation: put in v-decorator object
  */
 
-export default Vue.extend({
+export default mixins(FormControlMixin).extend({
   name: 'PatientInput',
   inheritAttrs: false,
-  mixins: [FormControlMixin],
   props: {
     placeholder: { default: 'Suche über ID, Name, Telefon, Mail' },
     value: { default: '' },
@@ -57,7 +57,7 @@ export default Vue.extend({
         label: this.getPatientLabel(patient),
         value: patient.id,
       }]
-      return patient.id
+      return patient.id || ''
     } else {
       return val
     }
diff --git a/client/src/util/forms.ts b/client/src/util/forms.ts
index 16d91afa..7cc4154d 100644
--- a/client/src/util/forms.ts
+++ b/client/src/util/forms.ts
@@ -1,3 +1,5 @@
+import Vue from 'vue'
+
 // Realise camelCase prefixing, whereas the prefixed name starts with capital
 function prefixed(name: string, prefix?: string): string {
   if (!prefix) {
@@ -16,25 +18,31 @@ function prefixedKeysArray(keys: string[], prefix?: string): string[] {
 }
 
 declare interface FormGroupMixinType {
-    $options: {
-      name: string;
-      inputKeys: string[];
-    };
-    $props: {
-      inputKeyPrefix?: string;
-      inputKeys: { [x: string]: string };
-    };
-    $watch: any;
-    $forceUpdate: () => void;
+  $options: {
+    name: string;
+    inputKeys: string[];
+  };
+  $props: {
+    inputKeyPrefix?: string;
+    inputKeys: { [x: string]: string };
+  };
+  $watch: any;
+  $forceUpdate: () => void;
+
+  formInputKey: (this: FormGroupMixinType, key: string) => string;
+  FormContext: any;
 
-    formInputKey: (this: FormGroupMixinType, key: string) => string;
-    FormContext: any;
+  prefixedKeysObject: (this: FormGroupMixinType, keys: {[x: string]: any}, prefix?: string) => {[x: string]: any};
+  prefixedKeysArray: (this: FormGroupMixinType, keys: string[], prefix?: string) => string[];
+}
 
-    prefixedKeysObject: (this: FormGroupMixinType, keys: {[x: string]: any}, prefix?: string) => {[x: string]: any};
-    prefixedKeysArray: (this: FormGroupMixinType, keys: string[], prefix?: string) => string[];
+declare module 'vue/types/options' {
+  interface ComponentOptions<V extends Vue> {
+    inputKeys?: string[];
+  }
 }
 
-export const FormGroupMixin = {
+export const FormGroupMixin = Vue.extend({
   props: {
     inputKeyPrefix: {
       default: undefined,
@@ -47,20 +55,22 @@ export const FormGroupMixin = {
     FormContext: { default: () => ({}) },
   },
   mounted(this: FormGroupMixinType) {
-    // Make sure all form items use selfUpdate; this is crucial for form items
-    // in the group to be re-rendered correctly when new values are set
-    this.$options.inputKeys.forEach((key: string) => {
-      if (!this.FormContext.form.formItems[this.formInputKey(key)].itemSelfUpdate) {
-        console.error(`[ ${this.$options.name} ]: ` +
-          `\`itemSelfUpdate\` is not enabled for form item of \`${key}\`. ` +
-          'This may lead to contents not being re-rendered when their ' +
-          'value is modified by calling `setFieldsValue` on its ' +
-          'containing form. To fix this, add `:selfUpdate="true"` to ' +
-          `the \`a-form-item\` component containing the \`${key}\` control ` +
-          'or add `:selfUpdate="true"` to the root `a-form` element.',
-        )
-      }
-    })
+    if (this.$options.inputKeys) {
+      // Make sure all form items use selfUpdate; this is crucial for form items
+      // in the group to be re-rendered correctly when new values are set
+      this.$options.inputKeys.forEach((key: string) => {
+        if (!this.FormContext.form.formItems[this.formInputKey(key)].itemSelfUpdate) {
+          console.error(`[ ${this.$options.name} ]: ` +
+            `\`itemSelfUpdate\` is not enabled for form item of \`${key}\`. ` +
+            'This may lead to contents not being re-rendered when their ' +
+            'value is modified by calling `setFieldsValue` on its ' +
+            'containing form. To fix this, add `:selfUpdate="true"` to ' +
+            `the \`a-form-item\` component containing the \`${key}\` control ` +
+            'or add `:selfUpdate="true"` to the root `a-form` element.',
+          )
+        }
+      })
+    }
   },
   methods: {
     formInputKey(this: FormGroupMixinType, key: string): string {
@@ -76,6 +86,10 @@ export const FormGroupMixin = {
       return prefixedKeysArray(keys, this.$props.inputKeyPrefix)
     },
     setData(this: FormGroupMixinType, data: {[x: string]: any}, usesPrefixedKeys: boolean | undefined) {
+      if (!this.$options.inputKeys) {
+        throw new Error(`[ ${this.$options.name} ]: \`setData\` not supported`)
+      }
+
       if (!usesPrefixedKeys) {
         data = this.prefixedKeysObject(data)
       }
@@ -88,6 +102,10 @@ export const FormGroupMixin = {
       this.FormContext.form.setFieldsValue(data)
     },
     getData(this: FormGroupMixinType, fieldNames?: string[], usesPrefixedKeys?: boolean): {[x: string]: any} {
+      if (!this.$options.inputKeys) {
+        throw new Error(`[ ${this.$options.name} ]: \`getData\` not supported`)
+      }
+
       if (fieldNames !== undefined && !usesPrefixedKeys) {
         fieldNames = this.prefixedKeysArray(fieldNames)
       }
@@ -103,7 +121,7 @@ export const FormGroupMixin = {
       return this.FormContext.form.getFieldsValue(fieldNames)
     },
   },
-}
+})
 
 declare interface FormControlMixinType {
   $options: {
@@ -129,14 +147,20 @@ declare interface FormControlMixinType {
     };
   };
 
-  __convValue: any;
+  FormControlConvValue: any;
   fieldName: string | null;
   isDecoratedFormField(): boolean;
   getOwnValue(): any;
   setOwnValue(val: any): void;
 }
 
-export const FormControlMixin = {
+declare module 'vue/types/options' {
+  interface ComponentOptions<V extends Vue> {
+    fieldValueConvert?(value: any): any;
+  }
+}
+
+export const FormControlMixin = Vue.extend({
   inject: {
     FormContext: { default: null },
   },
@@ -151,7 +175,7 @@ export const FormControlMixin = {
   },
   data() {
     return {
-      __convValue: undefined,
+      FormControlConvValue: undefined,
     }
   },
   created(this: FormControlMixinType) {
@@ -161,13 +185,13 @@ export const FormControlMixin = {
         : 'value'
 
       this.$watch(valueProp, (value: any) => {
-        if (this.__convValue === value) {
+        if (this.FormControlConvValue === value) {
           // Value has already been converted
-          this.__convValue = undefined
-        } else {
-          const newValue = this.$options.fieldValueConvert?.call(this, value)
+          this.FormControlConvValue = undefined
+        } else if (this.$options.fieldValueConvert) {
+          const newValue = this.$options.fieldValueConvert.call(this, value)
           if (newValue !== value) {
-            this.__convValue = newValue
+            this.FormControlConvValue = newValue
             this.setOwnValue(newValue)
           }
         }
@@ -192,4 +216,4 @@ export const FormControlMixin = {
       return (this as {[x: string]: any})[valueProp]
     },
   },
-}
+})
diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index 36d0fdc2..cdd8f287 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -572,7 +572,7 @@ export default Vue.extend({
     persistExposureContact(): Promise<boolean> {
       const stringFromMoment = (value: Moment): string => value.format('YYYY-MM-DD')
 
-      return new Promise((resolve: () => void) => {
+      return new Promise((resolve: (success: boolean) => void) => {
         this.exposureContactForm.validateFields(async(err: Error[], values: {[x: string]: any}) => {
           if (err) {
             resolve(false)
diff --git a/client/yarn.lock b/client/yarn.lock
index 8e716e46..c166dfa1 100644
--- a/client/yarn.lock
+++ b/client/yarn.lock
@@ -9991,6 +9991,11 @@ vue-template-es2015-compiler@^1.9.0:
   resolved "https://registry.yarnpkg.com/vue-template-es2015-compiler/-/vue-template-es2015-compiler-1.9.1.tgz#1ee3bc9a16ecbf5118be334bb15f9c46f82f5825"
   integrity sha512-4gDntzrifFnCEvyoO8PqyJDmguXgVPxKiIxrBKjIowvL9l+N66196+72XVYR8BBf1Uv1Fgt3bGevJ+sEmxfZzw==
 
+vue-typed-mixins@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/vue-typed-mixins/-/vue-typed-mixins-0.2.0.tgz#d369c186a392780bbbe9f1b28a4cdcf62bec9053"
+  integrity sha512-0OxuinandPWv3nm5k/reYkuKtX3jjPZ40Sy9roJz0ih8PUzmI7zSRiXFEJ62LsyRegw9Tqy+qMkajk7ipKP8Vg==
+
 vue@^2.6.11:
   version "2.6.11"
   resolved "https://registry.yarnpkg.com/vue/-/vue-2.6.11.tgz#76594d877d4b12234406e84e35275c6d514125c5"

From 6a9b33b08e067ef2bf8204f954974e91851c9ed0 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Mon, 4 May 2020 17:14:13 +0200
Subject: [PATCH 08/17] Show infection source in patient details

---
 client/src/views/PatientDetails.vue           | 54 ++++++++++++++++++-
 .../imis/api/ExposureContactController.java   |  7 ++-
 .../ExposureContactRepository.java            |  3 +-
 3 files changed, 60 insertions(+), 4 deletions(-)

diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index cdd8f287..ccd8fbab 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -160,7 +160,43 @@
             <!-- Symptome und Risiken -->
             <a-row :gutter="8" style="margin-top: 8px;">
               <a-col
-                :md="12"
+                :md="8"
+              >
+                <a-card
+                  align="left"
+                  title="Infektionsstatus"
+                >
+                  <h4>Infektionsquelle:</h4>
+                  <div v-if="!!patientInfectionSource">
+                    <div>
+                      <a-icon type="user"/> Kontakt mit infizierter Person
+                    </div>
+                    <table class="compact" style="margin-top: 5px;">
+                      <tr>
+                        <td>Name:</td>
+                        <td>
+                          <a @click="showPatient(patientInfectionSource.source.id)">
+                            {{ patientInfectionSource.source.firstName }} {{ patientInfectionSource.source.lastName }}
+                          </a>
+                        </td>
+                      </tr>
+                      <tr>
+                        <td>Kontaktdatum:</td>
+                        <td>{{ moment(patientInfectionSource.dateOfContact).format('DD.MM.YYYY') }}</td>
+                      </tr>
+                      <tr>
+                        <td>Umstand:</td>
+                        <td>{{ patientInfectionSource.context }}</td>
+                      </tr>
+                    </table>
+                  </div>
+                  <div v-else>
+                    Unbekannt
+                  </div>
+                </a-card>
+              </a-col>
+              <a-col
+                :md="8"
                 :span="24"
               >
                 <a-card
@@ -171,7 +207,7 @@
                 </a-card>
               </a-col>
               <a-col
-                :md="12"
+                :md="8"
                 :span="24"
               >
                 <a-card
@@ -391,6 +427,7 @@ const columnsExposureContacts: Partial<Column>[] = [
 
 interface State {
   patient: undefined | Patient;
+  patientInfectionSource: undefined | ExposureContactFromServer;
   exposureContacts: ExposureContactFromServer[];
   exposureContactsLoading: boolean;
   exposureContactForm: any;
@@ -433,6 +470,7 @@ export default Vue.extend({
   data(): State {
     return {
       patient: undefined,
+      patientInfectionSource: undefined,
       exposureContacts: [],
       exposureContactsLoading: false,
       exposureContactForm: undefined,
@@ -488,6 +526,11 @@ export default Vue.extend({
       const patientGender = this.patient.gender || ''
       this.gender = patientGender === 'male' ? 'männlich' : patientGender === 'female' ? 'weiblich' : 'divers'
 
+      // Source of Infection
+      try {
+        this.patientInfectionSource = await Api.getExposureSourceContactForPatientUsingGet(patientId)
+      } catch (e) {}
+
       // Tests
       this.tests = await Api.getLabTestForPatientUsingGet(patientId)
 
@@ -599,6 +642,9 @@ export default Vue.extend({
       await Api.removeExposureContactUsingDelete(contactId)
       this.exposureContacts = this.exposureContacts.filter(contact => contact.id !== contactId)
     },
+    showPatient(patientId: string) {
+      this.$router.push({ name: 'patient-detail', params: { id: patientId } })
+    },
     moment,
   },
 })
@@ -610,4 +656,8 @@ export default Vue.extend({
     border-collapse: separate;
     border-spacing: 15px
   }
+
+  table.compact {
+    border-spacing: 15px 3px;
+  }
 </style>
diff --git a/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
index 47a0466d..29b94e34 100644
--- a/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
+++ b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
@@ -6,6 +6,7 @@
 
 import lombok.RequiredArgsConstructor;
 
+import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -14,6 +15,7 @@
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
 
 import de.coronavirus.imis.api.dto.ExposureContactDTO;
 import de.coronavirus.imis.domain.ExposureContact;
@@ -58,7 +60,10 @@ public List<ExposureContactDTO.FromServer> getExposureContactsForPatient(@PathVa
   }
   @GetMapping("/by-contact/{id}")
   public ExposureContactDTO.FromServer getExposureSourceContactForPatient(@PathVariable("id") String patientId) {
-    return exposureContactMapper.toExposureContactDTO(exposureContactRepository.findByContactId(patientId));
+    return exposureContactMapper.toExposureContactDTO(
+      exposureContactRepository.findByContactId(patientId)
+        .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND))
+    );
   }
 
   @DeleteMapping("/{id}")
diff --git a/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
index 736aee49..5c1ee960 100644
--- a/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
+++ b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
@@ -5,11 +5,12 @@
 import org.springframework.data.repository.query.Param;
 
 import java.util.List;
+import java.util.Optional;
 
 import de.coronavirus.imis.domain.ExposureContact;
 
 public interface ExposureContactRepository extends JpaRepository<ExposureContact, Long> {
 
 	List<ExposureContact> findBySourceId(String patientId);
-	ExposureContact findByContactId(String patientId);
+	Optional<ExposureContact> findByContactId(String patientId);
 }

From a26349d214fe765d6cb19a68ee9a8a6a18f277cd Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Mon, 4 May 2020 18:44:46 +0200
Subject: [PATCH 09/17] Introduce `InfectionSource` as superclass for different
 types of sources of infection (e.g. `ExposureContact`)

---
 .../imis/domain/ExposureContact.java          | 15 ++------
 .../imis/domain/GenericInfectionSource.java   | 12 +++++++
 .../imis/domain/InfectionSource.java          | 35 +++++++++++++++++++
 .../de/coronavirus/imis/domain/Patient.java   |  2 +-
 4 files changed, 51 insertions(+), 13 deletions(-)
 create mode 100644 server/src/main/java/de/coronavirus/imis/domain/GenericInfectionSource.java
 create mode 100644 server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java

diff --git a/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java b/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
index 5d175721..85ed06d9 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/ExposureContact.java
@@ -12,20 +12,11 @@
 import de.coronavirus.imis.repositories.PatientRepository;
 
 @Entity
-@Component
 @Data
 @Accessors(chain = true)
-public class ExposureContact {
-
-	@Id
-	@GeneratedValue
-	private long id;
-
+@DiscriminatorValue("person")
+public class ExposureContact extends InfectionSource {
 	@ManyToOne
 	private Patient source;
-	@OneToOne
-	private Patient contact;
-	private String context; // e.g. contact in a medical facility
-	private LocalDate dateOfContact;
-	private String comment;
+	private String context;
 }
diff --git a/server/src/main/java/de/coronavirus/imis/domain/GenericInfectionSource.java b/server/src/main/java/de/coronavirus/imis/domain/GenericInfectionSource.java
new file mode 100644
index 00000000..e347b137
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/domain/GenericInfectionSource.java
@@ -0,0 +1,12 @@
+package de.coronavirus.imis.domain;
+
+import javax.persistence.*;
+
+import lombok.Data;
+
+@Entity
+@Data
+@DiscriminatorValue("generic")
+public class GenericInfectionSource extends InfectionSource {
+  private String description;
+}
diff --git a/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java b/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java
new file mode 100644
index 00000000..4aa05b00
--- /dev/null
+++ b/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java
@@ -0,0 +1,35 @@
+package de.coronavirus.imis.domain;
+
+import java.time.LocalDate;
+
+import javax.persistence.*;
+
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import static com.fasterxml.jackson.annotation.JsonSubTypes.Type;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+import lombok.Data;
+
+@Entity
+@Data
+@Inheritance(strategy = InheritanceType.JOINED)
+@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
+@JsonTypeInfo(
+  use = JsonTypeInfo.Id.NAME,
+  property = "type",
+  include = JsonTypeInfo.As.PROPERTY
+)
+@JsonSubTypes({
+  @Type(name = "generic", value = GenericInfectionSource.class),
+  @Type(name = "person", value = ExposureContact.class)
+})
+public abstract class InfectionSource {
+  @Id
+  @GeneratedValue
+  private long id;
+
+  @OneToOne
+  private Patient contact;
+  private LocalDate dateOfContact;
+  private String comment;
+}
diff --git a/server/src/main/java/de/coronavirus/imis/domain/Patient.java b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
index 17d31a63..9738550d 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/Patient.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
@@ -73,7 +73,7 @@ public class Patient {
 
 	@JsonIgnore
 	@OneToOne(mappedBy = "contact")
-	private ExposureContact exposureSourceContact;
+	private InfectionSource infectionSource;
 	@JsonIgnore
 	@OneToMany(mappedBy = "source")
 	private List<ExposureContact> exposureContacts;

From d87d9e891daa094ad2df5e8853053c6ed9ac8566 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Tue, 5 May 2020 16:59:42 +0200
Subject: [PATCH 10/17] Align to design proposal of #249

---
 client/src/views/PatientDetails.vue | 219 ++++++++++++++++------------
 1 file changed, 126 insertions(+), 93 deletions(-)

diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index ccd8fbab..6d855548 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -8,11 +8,11 @@
     />
     <div style="max-width: 1020px; margin: 0 auto; padding: 0 1rem">
       <a-tabs
-        defaultActiveKey="1"
+        defaultActiveKey="overview"
         v-if="patient"
       >
         <a-tab-pane
-          key="1"
+          key="overview"
           tab="Stammdaten"
         >
           <div style="display: flex; justify-content: flex-end; padding-bottom: 10px">
@@ -160,43 +160,7 @@
             <!-- Symptome und Risiken -->
             <a-row :gutter="8" style="margin-top: 8px;">
               <a-col
-                :md="8"
-              >
-                <a-card
-                  align="left"
-                  title="Infektionsstatus"
-                >
-                  <h4>Infektionsquelle:</h4>
-                  <div v-if="!!patientInfectionSource">
-                    <div>
-                      <a-icon type="user"/> Kontakt mit infizierter Person
-                    </div>
-                    <table class="compact" style="margin-top: 5px;">
-                      <tr>
-                        <td>Name:</td>
-                        <td>
-                          <a @click="showPatient(patientInfectionSource.source.id)">
-                            {{ patientInfectionSource.source.firstName }} {{ patientInfectionSource.source.lastName }}
-                          </a>
-                        </td>
-                      </tr>
-                      <tr>
-                        <td>Kontaktdatum:</td>
-                        <td>{{ moment(patientInfectionSource.dateOfContact).format('DD.MM.YYYY') }}</td>
-                      </tr>
-                      <tr>
-                        <td>Umstand:</td>
-                        <td>{{ patientInfectionSource.context }}</td>
-                      </tr>
-                    </table>
-                  </div>
-                  <div v-else>
-                    Unbekannt
-                  </div>
-                </a-card>
-              </a-col>
-              <a-col
-                :md="8"
+                :md="12"
                 :span="24"
               >
                 <a-card
@@ -207,7 +171,7 @@
                 </a-card>
               </a-col>
               <a-col
-                :md="8"
+                :md="12"
                 :span="24"
               >
                 <a-card
@@ -251,7 +215,7 @@
         </a-tab-pane>
         <a-tab-pane
           forceRender
-          key="2"
+          key="timeline"
           tab="Verlauf"
         >
           <a-card>
@@ -273,57 +237,103 @@
         </a-tab-pane>
         <a-tab-pane
           forceRender
-          key="3"
-          tab="Kontaktpersonen">
-          <!-- exposed contacts -->
-          <a-card>
-            <div slot="extra">
-              <a-button
-                icon="plus"
-                @click="addExposureContact">
-                Hinzufügen
-              </a-button>
-            </div>
+          key="infection-chain"
+          tab="Infektionskette">
 
-            <a-table
-              :columns="columnsExposureContacts"
-              :dataSource="exposureContacts"
-              class="imis-table-no-pagination"
-              :rowKey="contact => contact.contact.id"
-              :loading="exposureContactsLoading"
-              :customRow="contact => ({
-                on: { dblclick: () => showExposureContact(contact.id) }
-              })">
-              <template slot="dateOfContact" slot-scope="contact">
-                {{ moment(contact.dateOfContact).format('DD.MM.YYYY') }}
-              </template>
-              <template slot="infectionState" slot-scope="contact">
-                <span v-if="contact.contact.infected"
-                  style="color: red;">
-                  Infiziert
-                </span>
-                <span v-else>
+          <a-row :gutter="8" style="margin-top: 8px;">
+            <a-card
+              align="left"
+              title="Infektionsquelle"
+            >
+              <table>
+                <tr v-if="!!patientInfectionSource">
+                  <td>
+                    <a-icon type="user"/> Kontakt mit infizierter Person
+                  </td>
+                  <td>
+                    <a @click="showPatient(patientInfectionSource.source.id)">
+                      {{ patientInfectionSource.source.firstName }} {{ patientInfectionSource.source.lastName }},
+                    </a>
+                  </td>
+                  <td>{{ moment(patientInfectionSource.dateOfContact).format('DD.MM.YYYY') }};</td>
+                  <td>{{ patientInfectionSource.context }}</td>
+                </tr>
+                <tr v-else>
                   Unbekannt
-                </span>
-              </template>
-              <template slot="quarantineState" slot-scope="contact">
-                <span v-if="contact.contact.inQuarantine">
-                  In Quarantäne
-                </span>
-                <span v-else
-                  :style="`color: ${contact.contact.infected ? 'red' : 'unset'};`">
-                  Keine Quarantäne
-                </span>
-              </template>
-              <template slot="actions" slot-scope="contact">
-                <a-button ghost
-                  icon="close"
-                  type="danger"
-                  title="Entfernen"
-                  @click="removeExposureContact(contact.id)"/>
-              </template>
-            </a-table>
-          </a-card>
+                </tr>
+              </table>
+            </a-card>
+          </a-row>
+
+          <!-- exposed contacts -->
+          <a-row :gutter="8" style="margin-top: 8px;">
+            <a-card
+              title="Kontaktpersonen"
+              align="left"
+            >
+              <div slot="extra">
+                <a-button
+                  icon="plus"
+                  type="primary"
+                  @click="addExposureContact">
+                  Hinzufügen
+                </a-button>
+              </div>
+
+              <a-table
+                :columns="columnsExposureContacts"
+                :dataSource="exposureContacts"
+                class="imis-table-no-pagination"
+                :rowKey="contact => contact.contact.id"
+                :loading="exposureContactsLoading"
+                :customRow="contact => ({
+                  on: { dblclick: () => showExposureContact(contact.id) }
+                })">
+                <template slot="gotoPatient" slot-scope="contact">
+                  <a-button ghost
+                    icon="user"
+                    type="primary"
+                    title="Patientendaten anzeigen"
+                    @click="showPatient(contact.contact.id)"/>
+                </template>
+                <template slot="dateOfContact" slot-scope="contact">
+                  {{ moment(contact.dateOfContact).format('DD.MM.YYYY') }}
+                </template>
+                <template slot="infectionState" slot-scope="contact">
+                  <span v-if="contact.contact.infected"
+                    style="color: red;">
+                    Infiziert
+                  </span>
+                  <span v-else>
+                    Unbekannt
+                  </span>
+                </template>
+                <template slot="quarantineState" slot-scope="contact">
+                  <span v-if="contact.contact.inQuarantine">
+                    In Quarantäne
+                  </span>
+                  <span v-else
+                    :style="`color: ${contact.contact.infected ? 'red' : 'unset'};`">
+                    Keine Quarantäne
+                  </span>
+                </template>
+                <template slot="actions" slot-scope="contact">
+                  <div class="inline-buttons">
+                    <a-button ghost
+                      icon="edit"
+                      type="primary"
+                      title="Bearbeiten"
+                      @click="showExposureContact(contact.id)"/>
+                    <a-button ghost
+                      icon="close"
+                      type="danger"
+                      title="Entfernen"
+                      @click="removeExposureContact(contact.id)"/>
+                  </div>
+                </template>
+              </a-table>
+            </a-card>
+          </a-row>
           <a-modal title="Kontaktperson bearbeiten"
             ref="exposureContactModal"
             :visible="!!exposureContactInEditing"
@@ -383,6 +393,14 @@ const columnsTests: Partial<Column>[] = [
 ]
 
 const columnsExposureContacts: Partial<Column>[] = [
+  {
+    key: 'gotoPatient',
+    width: '40pt',
+    align: 'center',
+    scopedSlots: {
+      customRender: 'gotoPatient',
+    },
+  },
   {
     title: 'Nachname',
     key: 'lastName',
@@ -417,7 +435,7 @@ const columnsExposureContacts: Partial<Column>[] = [
   {
     title: 'Aktionen',
     key: 'actions',
-    width: '70pt',
+    width: '120pt',
     align: 'center',
     scopedSlots: {
       customRender: 'actions',
@@ -529,7 +547,9 @@ export default Vue.extend({
       // Source of Infection
       try {
         this.patientInfectionSource = await Api.getExposureSourceContactForPatientUsingGet(patientId)
-      } catch (e) {}
+      } catch (e) {
+        this.patientInfectionSource = undefined
+      }
 
       // Tests
       this.tests = await Api.getLabTestForPatientUsingGet(patientId)
@@ -654,10 +674,23 @@ export default Vue.extend({
 <style scoped lang="scss">
   table {
     border-collapse: separate;
-    border-spacing: 15px
+    border-spacing: 5px;
+
+    tr {
+      padding: 15px;
+
+      td:first-of-type {
+        padding-right: 15px;
+      }
+    }
   }
 
   table.compact {
     border-spacing: 15px 3px;
   }
+
+  .inline-buttons > button {
+    margin-left: 2px;
+    margin-right: 2px;
+  }
 </style>

From 1ce14ef54b9c1873d23b0c40211375620da726c3 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Tue, 5 May 2020 17:20:13 +0200
Subject: [PATCH 11/17] Some additional UI refinements

---
 client/src/components/EditExposureContact.vue | 2 ++
 client/src/util/forms.ts                      | 5 +++++
 client/src/views/PatientDetails.vue           | 1 +
 3 files changed, 8 insertions(+)

diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
index 7d2973a8..4aa2f78e 100644
--- a/client/src/components/EditExposureContact.vue
+++ b/client/src/components/EditExposureContact.vue
@@ -50,6 +50,7 @@
         <a-form-item label="Datum des Kontakts"
           :selfUpdate="true">
           <date-input
+            :disabledDate="date => date.isAfter(moment())"
             v-decorator="[ formInputKey('dateOfContact'), {
               rules: [
                 { required: true, message: 'Bitte ein gültiges Datum angeben' },
@@ -119,6 +120,7 @@ export default mixins(FormGroupMixin).extend({
     }
   },
   methods: {
+    moment,
   },
 } as any)
 </script>
diff --git a/client/src/util/forms.ts b/client/src/util/forms.ts
index 7cc4154d..03ac05b0 100644
--- a/client/src/util/forms.ts
+++ b/client/src/util/forms.ts
@@ -34,6 +34,7 @@ declare interface FormGroupMixinType {
 
   prefixedKeysObject: (this: FormGroupMixinType, keys: {[x: string]: any}, prefix?: string) => {[x: string]: any};
   prefixedKeysArray: (this: FormGroupMixinType, keys: string[], prefix?: string) => string[];
+  getData(this: FormGroupMixinType, fieldNames?: string[], usesPrefixedKeys?: boolean): {[x: string]: any};
 }
 
 declare module 'vue/types/options' {
@@ -120,6 +121,10 @@ export const FormGroupMixin = Vue.extend({
       }
       return this.FormContext.form.getFieldsValue(fieldNames)
     },
+    getSingleValue(this: FormGroupMixinType, fieldName: string, usesPrefixedKeys?: boolean): any | undefined {
+      const key = usesPrefixedKeys ? fieldName : this.formInputKey(fieldName)
+      return this.getData([key], true)[key]
+    },
   },
 })
 
diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index 6d855548..04d0042e 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -282,6 +282,7 @@
 
               <a-table
                 :columns="columnsExposureContacts"
+                :pagination="false"
                 :dataSource="exposureContacts"
                 class="imis-table-no-pagination"
                 :rowKey="contact => contact.contact.id"

From 6811aad7ce3ce4be51297130cd1932dff9f636bc Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Wed, 6 May 2020 16:37:56 +0200
Subject: [PATCH 12/17] Fix some PatientInput and DateInput usages to use
 standard form item + v-decorator format

---
 client/src/views/RegisterPatient.vue  | 20 +++++++++-------
 client/src/views/SendToQuarantine.vue | 34 +++++++++++++--------------
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/client/src/views/RegisterPatient.vue b/client/src/views/RegisterPatient.vue
index f3feb1b3..2f57f946 100644
--- a/client/src/views/RegisterPatient.vue
+++ b/client/src/views/RegisterPatient.vue
@@ -218,16 +218,20 @@
             <a-row>
               <a-col :span="1"></a-col>
               <a-col :span="8">
-                <DateInput :decorator="['dateOfIllness', { rules: [{
-                      required: true,
-                      message: 'Bitte Erkrankungsdatum wählen',
-                    }], initialValue: today}]" label="Erkrankungsdatum" />
+                <a-form-item label="Erkrankungsdatum">
+                  <DateInput v-decorator="['dateOfIllness', { rules: [{
+                        required: true,
+                        message: 'Bitte Erkrankungsdatum wählen',
+                      }], initialValue: today}]" />
+                </a-form-item>
               </a-col>
               <a-col :span="8">
-                <DateInput :decorator="['dateOfReporting', { rules: [{
-                      required: true,
-                      message: 'Bitte Meldedatum wählen'
-                    }], initialValue: today}]" label="Meldedatum" />
+                <a-form-item label="Meldedatum">
+                  <DateInput v-decorator="['dateOfReporting', { rules: [{
+                        required: true,
+                        message: 'Bitte Meldedatum wählen'
+                      }], initialValue: today}]" />
+                </a-form-item>
               </a-col>
             </a-row>
             <a-row>
diff --git a/client/src/views/SendToQuarantine.vue b/client/src/views/SendToQuarantine.vue
index 7a72be33..29fe522c 100644
--- a/client/src/views/SendToQuarantine.vue
+++ b/client/src/views/SendToQuarantine.vue
@@ -7,24 +7,24 @@
       @submit.prevent="handleSubmit"
     > <!-- :colon="false" -->
 
-      <PatientInput
-        v-if="this.showPatientInput"
-        :form="form"
-        :validation="['patientId',{ rules: [{
-          required: true,
-          message: 'Bitte geben Sie die Patienten-ID ein.'
-        }]}]"
-        label="Patienten-ID"
-      />
+      <a-form-item label="Patienten-ID"
+        v-if="this.showPatientInput">
+        <PatientInput
+          v-decorator="['patientId',{ rules: [{
+            required: true,
+            message: 'Bitte geben Sie die Patienten-ID ein.'
+          }]}]"
+        />
+      </a-form-item>
 
-      <DateInput
-        :form="form"
-        :decorator="['dateUntil', { rules: [{
-          required: true,
-          message: 'Bis wann soll der Patient in Quarantäne?',
-        }]}]"
-        label="Quarantäne bis"
-      />
+      <a-form-item label="Quarantäne bis">
+        <DateInput
+          v-decorator="['dateUntil', { rules: [{
+            required: true,
+            message: 'Bis wann soll der Patient in Quarantäne?',
+          }]}]"
+        />
+      </a-form-item>
 
       <!-- Kommentar -->
       <a-form-item label="Kommentar">

From d37119708d5fa657d3b1b6a9811f56e9179bf5a4 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Wed, 6 May 2020 20:18:31 +0200
Subject: [PATCH 13/17] Restrict REST API access to health institutions

---
 .../java/de/coronavirus/imis/config/SpringSecurityConfig.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java b/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
index 24c14db0..8cbf114d 100644
--- a/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
+++ b/server/src/main/java/de/coronavirus/imis/config/SpringSecurityConfig.java
@@ -62,7 +62,7 @@ protected void configure(HttpSecurity http) throws Exception {
 				.antMatchers(OPTIONS, "/**").permitAll()
 				.antMatchers("/api/auth").permitAll()
 				.antMatchers(API_PREFIX + "/patients").hasAnyRole(DEPARTMENT_OF_HEALTH, CLINIC, DOCTORS_OFFICE, TEST_SITE)
-				.antMatchers(API_PREFIX + "/exposure-contacts/**").permitAll()
+				.antMatchers(API_PREFIX + "/exposure-contacts/**").hasAnyRole(DEPARTMENT_OF_HEALTH, CLINIC, DOCTORS_OFFICE, TEST_SITE)
 				.antMatchers(API_PREFIX + "/doctor/*").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC)
 				.mvcMatchers(POST, API_PREFIX + "/labtest").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC, TEST_SITE)
 				.antMatchers(API_PREFIX + "/labtest/patient/*").hasAnyRole(DEPARTMENT_OF_HEALTH, DOCTORS_OFFICE, CLINIC, TEST_SITE)

From 7e40ebae9fb1b84db1dac99566ae3b196685bf7c Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Wed, 6 May 2020 21:17:47 +0200
Subject: [PATCH 14/17] Restrain index patient from being selectable as his/her
 own contact

---
 client/src/components/EditExposureContact.vue | 20 ++++++++++++-------
 client/src/components/PatientInput.vue        |  3 ++-
 client/src/util/forms.ts                      |  8 ++++++++
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
index 4aa2f78e..4e3c1261 100644
--- a/client/src/components/EditExposureContact.vue
+++ b/client/src/components/EditExposureContact.vue
@@ -13,7 +13,9 @@
         label="Ursprungspatient"
         class="patient-input">
         <patient-input
+          v-bind="inputProps.source"
           :disabled="$props.disableOriginatorPatient"
+          :filterOption="filterSources"
           v-decorator="[ formInputKey('source'), {
               rules: [
                 { required: true, message: 'Bitte Ursprungspatienten angeben' },
@@ -29,17 +31,12 @@
         label="Kontaktperson"
         class="patient-input">
         <patient-input
+          v-bind="inputProps.contact"
           :disabled="$props.disableContactPatient"
+          :filterOption="filterContacts"
           v-decorator="[ formInputKey('contact'), {
               rules: [
                 { required: true, message: 'Bitte Kontaktperson angeben' },
-                /* {
-                  validator: (value) => {
-                    const sourceKey = formInputKey('source')
-                    if (value === getData(sourceKey)[sourceKey]) throw new Error()
-                  },
-                  message: 'Ursprungsperson und Kontaktperson dürfen nicht übereinstimmen!'
-                }, */
               ],
           }]"/>
       </a-form-item>
@@ -50,6 +47,7 @@
         <a-form-item label="Datum des Kontakts"
           :selfUpdate="true">
           <date-input
+            v-bind="inputProps.dateOfContact"
             :disabledDate="date => date.isAfter(moment())"
             v-decorator="[ formInputKey('dateOfContact'), {
               rules: [
@@ -62,6 +60,7 @@
         <a-form-item label="Umgebung / Kontext"
           :selfUpdate="true">
           <a-auto-complete
+            v-bind="inputProps.context"
             :dataSource="contexts"
             :filterOption="false"
             v-decorator="[ formInputKey('context'), {
@@ -77,6 +76,7 @@
       <a-form-item label="Sonstiges / Kommentar"
         :selfUpdate="true">
         <a-textarea
+          v-bind="inputProps.comment"
           v-decorator="[ formInputKey('comment'), {
             rules: [],
           }]"/>
@@ -121,6 +121,12 @@ export default mixins(FormGroupMixin).extend({
   },
   methods: {
     moment,
+    filterContacts(inputVal: string, option: any) {
+      return option.key !== this.getSingleValue('source')
+    },
+    filterSources(inputVal: string, option: any) {
+      return option.key !== this.getSingleValue('contact')
+    },
   },
 } as any)
 </script>
diff --git a/client/src/components/PatientInput.vue b/client/src/components/PatientInput.vue
index abd7bd6f..310ac0c5 100644
--- a/client/src/components/PatientInput.vue
+++ b/client/src/components/PatientInput.vue
@@ -4,7 +4,7 @@
                    :placeholder="placeholder"
                    :showSearch="true"
                    :showArrow="false"
-                   :filterOption="false"
+                   :filterOption="filterOption"
                    :value="value"
                    @search="handleSearch">
     <a-select-option v-for="entry in result"
@@ -42,6 +42,7 @@ export default mixins(FormControlMixin).extend({
   props: {
     placeholder: { default: 'Suche über ID, Name, Telefon, Mail' },
     value: { default: '' },
+    filterOption: { default: false },
   },
   model: {
     prop: 'value',
diff --git a/client/src/util/forms.ts b/client/src/util/forms.ts
index 03ac05b0..4db6bfc5 100644
--- a/client/src/util/forms.ts
+++ b/client/src/util/forms.ts
@@ -25,6 +25,7 @@ declare interface FormGroupMixinType {
   $props: {
     inputKeyPrefix?: string;
     inputKeys: { [x: string]: string };
+    inputProps: Record<string, any>;
   };
   $watch: any;
   $forceUpdate: () => void;
@@ -51,6 +52,13 @@ export const FormGroupMixin = Vue.extend({
     inputKeys: {
       default: () => ({}),
     },
+    inputProps: {
+      default(this: FormGroupMixinType) {
+        return Object.fromEntries(
+          this.$options.inputKeys!.map((key: string) => [key, {}]),
+        )
+      },
+    },
   },
   inject: {
     FormContext: { default: () => ({}) },

From a0caaad487969c227d94e0dd5069ffa19ef66343 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Wed, 6 May 2020 23:10:29 +0200
Subject: [PATCH 15/17] Allow multiple infection sources and refine UI for
 index patient information

---
 client/src/api/SwaggerApi.ts                  | 62 ++++++------
 client/src/components/EditExposureContact.vue |  8 +-
 client/src/views/PatientDetails.vue           | 94 ++++++++++++++-----
 3 files changed, 108 insertions(+), 56 deletions(-)

diff --git a/client/src/api/SwaggerApi.ts b/client/src/api/SwaggerApi.ts
index b6cd89dd..9a0961a8 100644
--- a/client/src/api/SwaggerApi.ts
+++ b/client/src/api/SwaggerApi.ts
@@ -737,13 +737,13 @@ export class Api<SecurityDataType = any> extends HttpClient<SecurityDataType> {
 
     /**
      * @tags exposure-contact-controller
-     * @name getExposureSourceContactForPatientUsingGET
-     * @summary getExposureSourceContactForPatient
+     * @name getExposureSourceContactsForPatientUsingGET
+     * @summary getExposureSourceContactsForPatient
      * @request GET:/api/exposure-contacts/by-contact/{id}
      * @secure
      */
-    getExposureSourceContactForPatientUsingGet: (id: string, params?: RequestParams) =>
-      this.request<ExposureContactFromServer, any>(
+    getExposureSourceContactsForPatientUsingGet: (id: string, params?: RequestParams) =>
+      this.request<ExposureContactFromServer[], any>(
         `/api/exposure-contacts/by-contact/${id}`,
         "GET",
         params,
@@ -1047,70 +1047,72 @@ export class Api<SecurityDataType = any> extends HttpClient<SecurityDataType> {
   error = {
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingGET
-     * @summary errorHtml
+     * @name errorUsingGET
+     * @summary error
      * @request GET:/error
      * @secure
      */
-    errorHtmlUsingGet: (params?: RequestParams) => this.request<ModelAndView, any>(`/error`, "GET", params, null, true),
+    errorUsingGet: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "GET", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingHEAD
-     * @summary errorHtml
+     * @name errorUsingHEAD
+     * @summary error
      * @request HEAD:/error
      * @secure
      */
-    errorHtmlUsingHead: (params?: RequestParams) =>
-      this.request<ModelAndView, any>(`/error`, "HEAD", params, null, true),
+    errorUsingHead: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "HEAD", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingPOST
-     * @summary errorHtml
+     * @name errorUsingPOST
+     * @summary error
      * @request POST:/error
      * @secure
      */
-    errorHtmlUsingPost: (params?: RequestParams) =>
-      this.request<ModelAndView, any>(`/error`, "POST", params, null, true),
+    errorUsingPost: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "POST", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingPUT
-     * @summary errorHtml
+     * @name errorUsingPUT
+     * @summary error
      * @request PUT:/error
      * @secure
      */
-    errorHtmlUsingPut: (params?: RequestParams) => this.request<ModelAndView, any>(`/error`, "PUT", params, null, true),
+    errorUsingPut: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "PUT", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingDELETE
-     * @summary errorHtml
+     * @name errorUsingDELETE
+     * @summary error
      * @request DELETE:/error
      * @secure
      */
-    errorHtmlUsingDelete: (params?: RequestParams) =>
-      this.request<ModelAndView, any>(`/error`, "DELETE", params, null, true),
+    errorUsingDelete: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "DELETE", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingOPTIONS
-     * @summary errorHtml
+     * @name errorUsingOPTIONS
+     * @summary error
      * @request OPTIONS:/error
      * @secure
      */
-    errorHtmlUsingOptions: (params?: RequestParams) =>
-      this.request<ModelAndView, any>(`/error`, "OPTIONS", params, null, true),
+    errorUsingOptions: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "OPTIONS", params, null, true),
 
     /**
      * @tags basic-error-controller
-     * @name errorHtmlUsingPATCH
-     * @summary errorHtml
+     * @name errorUsingPATCH
+     * @summary error
      * @request PATCH:/error
      * @secure
      */
-    errorHtmlUsingPatch: (params?: RequestParams) =>
-      this.request<ModelAndView, any>(`/error`, "PATCH", params, null, true),
+    errorUsingPatch: (params?: RequestParams) =>
+      this.request<Record<string, object>, any>(`/error`, "PATCH", params, null, true),
   };
 }
diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
index 4e3c1261..1f26575b 100644
--- a/client/src/components/EditExposureContact.vue
+++ b/client/src/components/EditExposureContact.vue
@@ -121,11 +121,11 @@ export default mixins(FormGroupMixin).extend({
   },
   methods: {
     moment,
-    filterContacts(inputVal: string, option: any) {
-      return option.key !== this.getSingleValue('source')
+    filterContacts(inputVal: string, option: any): boolean {
+      return option.key !== (this as any).getSingleValue('source')
     },
-    filterSources(inputVal: string, option: any) {
-      return option.key !== this.getSingleValue('contact')
+    filterSources(inputVal: string, option: any): boolean {
+      return option.key !== (this as any).getSingleValue('contact')
     },
   },
 } as any)
diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index 7d1566bb..78f14cc4 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -248,25 +248,36 @@
           <a-row :gutter="8" style="margin-top: 8px;">
             <a-card
               align="left"
-              title="Infektionsquelle"
+              title="Infektionsquellen"
             >
-              <table>
-                <tr v-if="!!patientInfectionSource">
-                  <td>
-                    <a-icon type="user"/> Kontakt mit infizierter Person
-                  </td>
-                  <td>
-                    <a @click="showPatient(patientInfectionSource.source.id)">
-                      {{ patientInfectionSource.source.firstName }} {{ patientInfectionSource.source.lastName }},
-                    </a>
-                  </td>
-                  <td>{{ moment(patientInfectionSource.dateOfContact).format('DD.MM.YYYY') }};</td>
-                  <td>{{ patientInfectionSource.context }}</td>
-                </tr>
-                <tr v-else>
-                  Unbekannt
-                </tr>
-              </table>
+              <a-descriptions layout="vertical" :column="{ xs: 1, sm: 1, md: 2, lg: 2 }">
+                <a-descriptions-item>
+                  <span slot="label"><a-icon type="user" style="margin-right: 5px;"/> Kontakte mit Indexpatienten <span v-if="patientInfectionSources.length > 0">({{ patientInfectionSources.length }})</span></span>
+                  <div v-if="patientInfectionSources.length > 0">
+                    <a-table class="table-index-patients"
+                      :columns="columnsIndexPatients"
+                      :dataSource="patientInfectionSources"
+                      :rowKey="contact => contact.id"
+                      :showHeader="false"
+                      :pagination="false"
+                    >
+                      <template slot="name" slot-scope="contact">
+                        <a @click="showPatient(contact.source.id)">{{ contact.source.firstName }} {{ contact.source.lastName }}</a>,
+                      </template>
+                      <template slot="dateOfContact" slot-scope="contact">
+                        am {{ moment(contact.dateOfContact).format('DD.MM.YYYY') }},
+                      </template>
+                    </a-table>
+                  </div>
+                  <div v-else>
+                    Keine bekannt
+                  </div>
+                </a-descriptions-item>
+                <a-descriptions-item
+                  label="Sonstige">
+                  Keine bekannt
+                </a-descriptions-item>
+              </a-descriptions>
             </a-card>
           </a-row>
 
@@ -456,9 +467,31 @@ const columnsExposureContacts: Partial<Column>[] = [
   },
 ]
 
+const columnsIndexPatients = [
+  {
+    title: 'Name',
+    key: 'name',
+    scopedSlots: {
+      customRender: 'name',
+    },
+  },
+  {
+    title: 'Kontaktdatum',
+    key: 'dateOfContact',
+    scopedSlots: {
+      customRender: 'dateOfContact',
+    },
+  },
+  {
+    title: 'Wie?',
+    key: 'context',
+    dataIndex: 'context',
+  },
+]
+
 interface State {
   patient: undefined | Patient;
-  patientInfectionSource: undefined | ExposureContactFromServer;
+  patientInfectionSources: ExposureContactFromServer[];
   exposureContacts: ExposureContactFromServer[];
   exposureContactsLoading: boolean;
   exposureContactForm: any;
@@ -473,6 +506,7 @@ interface State {
   tests: LabTest[];
   columnsTests: Partial<Column>[];
   columnsExposureContacts: Partial<Column>[];
+  columnsIndexPatients: Partial<Column>[];
   testResults: TestResultType[];
   testTypes: TestTypeItem[];
   dateOfReporting: string;
@@ -505,7 +539,7 @@ export default Vue.extend({
     return {
       dateFormat: 'DD.MM.YYYY',
       patient: undefined,
-      patientInfectionSource: undefined,
+      patientInfectionSources: [],
       exposureContacts: [],
       exposureContactsLoading: false,
       exposureContactForm: undefined,
@@ -522,6 +556,7 @@ export default Vue.extend({
       tests: [],
       columnsTests,
       columnsExposureContacts,
+      columnsIndexPatients,
       dateOfReporting: '',
       dateOfIllness: '',
     }
@@ -578,9 +613,9 @@ export default Vue.extend({
 
       // Source of Infection
       try {
-        this.patientInfectionSource = await Api.getExposureSourceContactForPatientUsingGet(patientId)
+        this.patientInfectionSources = await Api.getExposureSourceContactsForPatientUsingGet(patientId)
       } catch (e) {
-        this.patientInfectionSource = undefined
+        this.patientInfectionSources = []
       }
 
       // Tests
@@ -746,3 +781,18 @@ export default Vue.extend({
     color: rgba(0, 0, 0, 0.65);
   }
 </style>
+
+<style lang="scss">
+  .table-index-patients {
+    table {
+      width: unset;
+    }
+    .ant-table-tbody > tr > td {
+      border-bottom: none;
+      padding: 4px;
+    }
+  }
+  .ant-descriptions-item {
+    vertical-align: top;
+  }
+</style>

From f80e52c61b7f14f1ec154df8b064b72a004da5b4 Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Wed, 6 May 2020 23:34:47 +0200
Subject: [PATCH 16/17] Add small infection chain widget to patient's case file
 overview

---
 client/src/views/PatientDetails.vue           | 29 +++++++++++++++++--
 .../imis/api/ExposureContactController.java   |  9 +++---
 .../imis/domain/InfectionSource.java          |  2 +-
 .../de/coronavirus/imis/domain/Patient.java   |  4 +--
 .../ExposureContactRepository.java            |  2 +-
 5 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/client/src/views/PatientDetails.vue b/client/src/views/PatientDetails.vue
index 78f14cc4..dd4a29d1 100644
--- a/client/src/views/PatientDetails.vue
+++ b/client/src/views/PatientDetails.vue
@@ -192,7 +192,32 @@
             <!-- Symptome und Risiken -->
             <a-row :gutter="8" style="margin-top: 8px;">
               <a-col
-                :md="12"
+                :md="8"
+                :span="24"
+              >
+                <a-card
+                  align="left"
+                  title="Infektionskette"
+                >
+                  <a-descriptions layout="vertical" :column="1">
+                    <a-descriptions-item>
+                      <span slot="label"><a-icon type="arrow-right"/><a-icon type="user" style="margin-right: 5px;"/> Kontakte mit Indexpatienten</span>
+                      <span v-if="patientInfectionSources.length > 0">{{ patientInfectionSources.length }}</span>
+                      <span v-else>Keine</span>
+                      bekannt
+                    </a-descriptions-item>
+                    <a-descriptions-item>
+                      <span slot="label"><a-icon type="user"/><a-icon type="arrow-right" style="margin-right: 5px;"/> Eigene Kontaktpersonen</span>
+                      <span v-if="exposureContacts.length > 0">{{ exposureContacts.length }}</span>
+                      <span v-else>Keine</span>
+                      angegeben
+                    </a-descriptions-item>
+                  </a-descriptions>
+                </a-card>
+              </a-col>
+
+              <a-col
+                :md="8"
                 :span="24"
               >
                 <a-card
@@ -203,7 +228,7 @@
                 </a-card>
               </a-col>
               <a-col
-                :md="12"
+                :md="8"
                 :span="24"
               >
                 <a-card
diff --git a/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
index 29b94e34..9930e6ac 100644
--- a/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
+++ b/server/src/main/java/de/coronavirus/imis/api/ExposureContactController.java
@@ -59,11 +59,10 @@ public List<ExposureContactDTO.FromServer> getExposureContactsForPatient(@PathVa
       .collect(Collectors.toList());
   }
   @GetMapping("/by-contact/{id}")
-  public ExposureContactDTO.FromServer getExposureSourceContactForPatient(@PathVariable("id") String patientId) {
-    return exposureContactMapper.toExposureContactDTO(
-      exposureContactRepository.findByContactId(patientId)
-        .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND))
-    );
+  public List<ExposureContactDTO.FromServer> getExposureSourceContactsForPatient(@PathVariable("id") String patientId) {
+    return exposureContactRepository.findByContactId(patientId)
+      .stream().map(contact -> exposureContactMapper.toExposureContactDTO(contact))
+      .collect(Collectors.toList());
   }
 
   @DeleteMapping("/{id}")
diff --git a/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java b/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java
index 4aa05b00..440b64b3 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/InfectionSource.java
@@ -28,7 +28,7 @@ public abstract class InfectionSource {
   @GeneratedValue
   private long id;
 
-  @OneToOne
+  @ManyToOne
   private Patient contact;
   private LocalDate dateOfContact;
   private String comment;
diff --git a/server/src/main/java/de/coronavirus/imis/domain/Patient.java b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
index 9738550d..7e67fca2 100644
--- a/server/src/main/java/de/coronavirus/imis/domain/Patient.java
+++ b/server/src/main/java/de/coronavirus/imis/domain/Patient.java
@@ -72,8 +72,8 @@ public class Patient {
 	private Boolean coronaContacts;
 
 	@JsonIgnore
-	@OneToOne(mappedBy = "contact")
-	private InfectionSource infectionSource;
+	@OneToMany(mappedBy = "contact")
+	private List<InfectionSource> infectionSource;
 	@JsonIgnore
 	@OneToMany(mappedBy = "source")
 	private List<ExposureContact> exposureContacts;
diff --git a/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
index 5c1ee960..479463b8 100644
--- a/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
+++ b/server/src/main/java/de/coronavirus/imis/repositories/ExposureContactRepository.java
@@ -12,5 +12,5 @@
 public interface ExposureContactRepository extends JpaRepository<ExposureContact, Long> {
 
 	List<ExposureContact> findBySourceId(String patientId);
-	Optional<ExposureContact> findByContactId(String patientId);
+	List<ExposureContact> findByContactId(String patientId);
 }

From 7ed93da92552dbf658fc5a24c766e8b61c17038e Mon Sep 17 00:00:00 2001
From: Jan-Niklas Brandes <janniklasbrandes@aol.de>
Date: Sat, 9 May 2020 18:50:24 +0200
Subject: [PATCH 17/17] Add space to date and context fields of
 EditExposureContact component

---
 client/src/components/EditExposureContact.vue | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/client/src/components/EditExposureContact.vue b/client/src/components/EditExposureContact.vue
index 1f26575b..622d147f 100644
--- a/client/src/components/EditExposureContact.vue
+++ b/client/src/components/EditExposureContact.vue
@@ -43,7 +43,7 @@
     </a-row>
     <a-row>
       <!-- When and How -->
-      <a-col :md="12" :sm="24">
+      <a-col :md="11" :sm="24">
         <a-form-item label="Datum des Kontakts"
           :selfUpdate="true">
           <date-input
@@ -56,7 +56,8 @@
             }]"/>
         </a-form-item>
       </a-col>
-      <a-col :md="12" :sm="24">
+      <a-col :md="2" :sm="0"></a-col>
+      <a-col :md="11" :sm="24">
         <a-form-item label="Umgebung / Kontext"
           :selfUpdate="true">
           <a-auto-complete