#2 Zwischenstand: Neue Klassen

sormas-api/src/de/symeda/sormas/api/person/PersonDto.java

@@ -0,0 +1,40 @@
+package de.symeda.sormas.api.person;
+
+import de.symeda.sormas.api.caze.DataTransferObject;
+
+public class PersonDto extends DataTransferObject {
+
+	private static final long serialVersionUID = -8558187171374254398L;
+
+	public static final String FIRST_NAME = "firstName";
+	public static final String LAST_NAME = "lastName";
+
+	private String firstName;
+	private String lastName;
+
+
+
+	public String getFirstName() {
+		return firstName;
+	}
+
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+
+	public String getLastName() {
+		return lastName;
+	}
+
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+
+
+	@Override
+	public String toString() {
+		return firstName + " " + lastName;
+	}
+
+
+}

sormas-api/src/de/symeda/sormas/api/person/PersonFacade.java

@@ -0,0 +1,15 @@
+package de.symeda.sormas.api.person;
+
+import java.util.List;
+
+import javax.ejb.Remote;
+
+@Remote
+public interface PersonFacade {
+
+    public abstract List<PersonDto> getAllPerson();
+
+    public abstract PersonDto getByUuid(String uuid);
+
+    public abstract PersonDto savePerson(PersonDto dto);
+}

sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseFacadeEjb.java

@@ -0,0 +1,86 @@
+package de.symeda.sormas.backend.caze;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.ejb.EJB;
+import javax.ejb.Singleton;
+
+import de.symeda.sormas.api.caze.CaseDto;
+import de.symeda.sormas.api.caze.CaseFacade;
+import de.symeda.sormas.api.person.PersonDto;
+import de.symeda.sormas.api.person.PersonFacade;
+import de.symeda.sormas.backend.mock.MockDataGenerator;
+import de.symeda.sormas.backend.person.PersonFacadeEjb;
+import de.symeda.sormas.backend.person.PersonService;
+
+@Singleton(name = "CaseFacade")
+public class CaseFacadeEjb implements CaseFacade {
+
+	@EJB
+	private CaseService cs;
+
+	@EJB
+	private PersonService ps;
+
+	@EJB
+	private PersonFacade pf;
+
+	private List<CaseDto> cases;
+
+	@Override
+	public List<CaseDto> getAllCases() {
+		List<Case> casesDB = cs.getAll();
+		cases = new ArrayList<>();
+		if(casesDB!=null && casesDB.size()>0) {
+			for (Case caze : casesDB) {
+				cases.add(toDto(caze));
+			}
+		}
+		return cases;
+	}
+
+	@Override
+	public CaseDto getByUuid(String uuid) {
+		return cases.stream().filter(c -> c.getUuid().equals(uuid)).findFirst().orElse(null);
+	}
+
+	@Override
+	public CaseDto saveCase(CaseDto dto) {
+
+//		if(dto.getPerson() != null) {
+//			PersonDto personDto = pf.savePerson(dto.getPerson());
+//			dto.setPersonDto(personDto);
+//		}
+
+		Case caze = cs.toCase(dto);
+		cs.ensurePersisted(caze);
+
+		return toDto(caze);
+
+	}
+
+	@Override
+	public void createDemo() {
+		List<CaseDto> cases = MockDataGenerator.createCases();
+		for (CaseDto dto : cases) {
+			PersonDto personDto = MockDataGenerator.createPerson();
+			//personDto = pf.savePerson(personDto);
+			dto.setPersonDto(personDto);
+			saveCase(dto);
+
+		}
+	}
+
+	public static CaseDto toDto(Case caze) {
+		CaseDto dto = new CaseDto();
+		dto.setUuid(caze.getUuid());
+		dto.setCaseStatus(caze.getCaseStatus());
+		dto.setDescription(caze.getDescription());
+
+		dto.setPersonDto(PersonFacadeEjb.toDto(caze.getPerson()));
+
+		return dto;
+	}
+
+}

sormas-backend/src/main/java/de/symeda/sormas/backend/caze/CaseService.java

@@ -0,0 +1,58 @@
+package de.symeda.sormas.backend.caze;
+
+import javax.ejb.EJB;
+import javax.ejb.LocalBean;
+import javax.ejb.Stateless;
+import javax.validation.constraints.NotNull;
+
+import de.symeda.sormas.api.caze.CaseDto;
+import de.symeda.sormas.backend.common.AbstractAdoService;
+import de.symeda.sormas.backend.person.Person;
+import de.symeda.sormas.backend.person.PersonService;
+
+
+
+@Stateless
+@LocalBean
+//@RolesAllowed({
+//		Permission._ADMIN,
+//		Permission._USER })
+//@DeclareRoles({
+//		Permission._ADMIN,
+//		Permission._USER })
+public class CaseService extends AbstractAdoService<Case> {
+
+	@EJB
+	private PersonService ps;
+
+	public CaseService() {
+		super(Case.class);
+	}
+
+	public Case createCase(Person person) {
+
+		Case caze = new Case();
+		caze.setPerson(person);
+		return caze;
+	}
+
+	public Case toCase(@NotNull CaseDto dto) {
+		Case caze = getByUuid(dto.getUuid());
+
+		Person person;
+		if(dto.getPerson()!=null) {
+			person = ps.toPerson(dto.getPerson());
+		}
+		else {
+			person = ps.createPerson();
+		}
+		if(caze==null) {
+			caze = createCase(person);
+		}
+		caze.setUuid(dto.getUuid());
+		caze.setPerson(person);
+		caze.setDescription(dto.getDescription());
+		caze.setCaseStatus(dto.getCaseStatus());
+		return caze;
+	}
+}

sormas-backend/src/main/java/de/symeda/sormas/backend/common/AbstractAdoService.java

@@ -0,0 +1,177 @@
+package de.symeda.sormas.backend.common;
+
+import java.sql.Timestamp;
+import java.util.List;
+
+import javax.annotation.Resource;
+import javax.annotation.security.DeclareRoles;
+import javax.ejb.SessionContext;
+import javax.persistence.EntityExistsException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+
+
+import de.symeda.sormas.backend.common.AbstractDomainObject;
+import de.symeda.sormas.backend.user.Permission;
+import de.symeda.sormas.backend.util.ModelConstants;
+
+/**
+ * @author Martin Wahnschaffe
+ * @param <ADO>
+ */
+public abstract class AbstractAdoService<ADO extends AbstractDomainObject> implements AdoService<ADO> {
+
+
+	@Resource
+	private SessionContext context;
+
+	private final Class<ADO> elementClass;
+
+	@PersistenceContext(unitName = ModelConstants.PERSISTENCE_UNIT_NAME)
+	protected EntityManager em;
+
+	public AbstractAdoService(Class<ADO> elementClass) {
+		this.elementClass = elementClass;
+	}
+
+	protected Class<ADO> getElementClass() {
+		return elementClass;
+	}
+
+	@Override
+	protected Object clone() throws CloneNotSupportedException {
+		throw new CloneNotSupportedException();
+	}
+
+	@Override
+	public List<ADO> getAll() {
+
+		CriteriaBuilder cb = em.getCriteriaBuilder();
+		CriteriaQuery<ADO> cq = cb.createQuery(getElementClass());
+		Root<ADO> from = cq.from(getElementClass());
+		cq.orderBy(cb.asc(from.get(AbstractDomainObject.ID)));
+
+		return em.createQuery(cq).getResultList();
+	}
+
+	@Override
+	public ADO getById(long id) {
+		ADO result = em.find(getElementClass(), id);
+		return result;
+	}
+
+	@Override
+	public ADO getByUuid(String uuid) {
+		//ADO result = JpaHelper.simpleSingleQuery(em, getElementClass(), AbstractDomainObject.UUID, uuid);
+		return null;
+	}
+
+	@Override
+	public void ensurePersisted(ADO ado) throws EntityExistsException {
+		if (ado.getId() == null) {
+			em.persist(ado);
+		} else if (!em.contains(ado)) {
+			throw new EntityExistsException("Das Entity ist nicht attacht: " + getElementClass().getSimpleName() + "#" + ado.getUuid());
+		}
+	}
+
+	@Override
+	public void persist(ADO persistme) {
+		em.persist(persistme);
+	}
+
+	@Override
+	public void delete(ADO deleteme) {
+		em.remove(deleteme);
+		em.flush();
+	}
+
+	@Override
+	public ADO merge(ADO mergeme) {
+		return em.merge(mergeme);
+	}
+
+	@Override
+	public void doFlush() {
+		em.flush();
+	}
+
+	/**
+	 * <u>Achtung:</u> Für korrekte Funktion muss die aufrufende Klasse {@link Permission#_SYSTEM_ROLE} in {@link DeclareRoles} definiert
+	 * haben.
+	 * 
+	 * @return {@code true}, wenn das System selbst der ausführende Benutzer ist.
+	 */
+	protected boolean isSystem() {
+		return context.isCallerInRole(Permission._SYSTEM_ROLE);
+	}
+
+	/**
+	 * <u>Achtung:</u> Für korrekte Funktion muss die aufrufende Klasse {@link Permission#_ADMIN} in {@link DeclareRoles} definiert
+	 * haben.
+	 * 
+	 * @return {@code true}, wenn der ausführende Benutzer {@link Permission#ADMIN} hat.
+	 */
+	protected boolean isAdmin() {
+		return hasPermission(Permission.ADMIN);
+	}
+
+	/**
+	 * <u>Achtung:</u> Für korrekte Funktion muss die aufrufende Klasse die entsprechende Permission in {@link DeclareRoles} definiert
+	 * haben.
+	 * 
+	 * @param permission
+	 * @return {@code true}, wenn der ausführende Benutzer die angegebene {@code permission} hat.
+	 */
+	protected boolean hasPermission(Permission permission) {
+		return context.isCallerInRole(permission.name());
+	}
+
+	protected Timestamp requestTransactionDate() {
+		return (Timestamp) this.em.createNativeQuery("SELECT NOW()").getSingleResult();
+	}
+
+	/**
+	 * Prüft, ob ein eindeutig zu vergebener Wert bereits durch eine andere Entity verwendet wird.
+	 * 
+	 * @param uuid
+	 *            uuid der aktuell in Bearbeitung befindlichen Entity.
+	 * @param propertyName
+	 *            Attribut-Name des zu prüfenden Werts.
+	 * @param propertyValue
+	 *            Zu prüfender eindeutiger Wert.
+	 * @return
+	 *         <ol>
+	 *         <li>{@code true}, wenn {@code propertyValue == null}.</li>
+	 *         <li>{@code true}, wenn {@code propertyValue} durch die Entity mit {@code uuid} verwendet wird.</li>
+	 *         <li>{@code false}, wenn {@code propertyValue} bereits durch einen andere Entity verwendet wird.</li>
+	 *         </ol>
+	 */
+	protected boolean isUnique(String uuid, String propertyName, Object propertyValue) {
+
+		if (propertyValue == null) {
+			return true;
+		} else {
+			ADO foundEntity = getByUniqueAttribute(propertyName, propertyValue);
+			return foundEntity == null || foundEntity.getUuid().equals(uuid);
+		}
+	}
+
+	/**
+	 * Lädt eine Entity anhand einem als eindeutig erwartetem Attribut.
+	 * 
+	 * @param propertyName
+	 *            Attribut-Name des zu prüfenden Werts.
+	 * @param propertyValue
+	 *            Zu prüfender eindeutiger Wert.
+	 * @return {@code null}, wenn es keine Entity gibt, die {@code propertyValue} gesetzt hat.
+	 */
+	protected ADO getByUniqueAttribute(String propertyName, Object propertyValue) {
+
+//		return JpaHelper.simpleSingleQuery(em, elementClass, propertyName, propertyValue);
+		return null;
+	}
+}