Initial graphql api implementation

code/moya-beans-client/ejbModule/fi/codecrew/moya/beans/AllergyBeanLocal.java

@@ -2,6 +2,7 @@ package fi.codecrew.moya.beans;
 
 import fi.codecrew.moya.model.Allergy;
 import fi.codecrew.moya.model.EventUser;
+import fi.codecrew.moya.model.User;
 import fi.codecrew.moya.model.UsersAllergy;
 
 import javax.ejb.Local;
@@ -13,6 +14,7 @@ public interface AllergyBeanLocal {
 
 	List<Allergy> getAllergies();
 
+	List<UsersAllergy> getUserAllergies(User currentUser);
 	List<UsersAllergy> getUserAllergies(EventUser currentUser);
 
 	List<UsersAllergy> saveAllergies(ArrayList<UsersAllergy> allergylist);

code/moya-beans-client/ejbModule/fi/codecrew/moya/beans/UserBeanLocal.java

@@ -208,4 +208,12 @@ public interface UserBeanLocal {
 	 * @return EventUser with the matching code
 	 */
 	EventUser findUserByCodeToken(String code);
+
+	/**
+	 * Return eventusers of all events for user
+	 * This function can only be used by users themselves, and superadmins.
+	 * @param user User to fetch eventusers for
+	 * @return Eventusers for all events this user has been associated to.
+	 */
+	List<EventUser> findAllEventusers(User user);
 }

code/moya-beans/ejbModule/fi/codecrew/moya/beans/AllergyBean.java

@@ -4,6 +4,7 @@ import fi.codecrew.moya.facade.AllergyFacade;
 import fi.codecrew.moya.facade.UsersAllergyFacade;
 import fi.codecrew.moya.model.Allergy;
 import fi.codecrew.moya.model.EventUser;
+import fi.codecrew.moya.model.User;
 import fi.codecrew.moya.model.UsersAllergy;
 
 import javax.ejb.EJB;
@@ -27,11 +28,16 @@ public class AllergyBean implements AllergyBeanLocal {
 	}
 
 	@Override
-	public List<UsersAllergy> getUserAllergies(EventUser user) {
+	public List<UsersAllergy> getUserAllergies(User user) {
 		return userAllergyFacade.findForUser(user);
 	}
 
 	@Override
+	public List<UsersAllergy> getUserAllergies(EventUser user) {
+		return userAllergyFacade.findForUser(user.getUser());
+	}
+
+	@Override
 	public List<UsersAllergy> saveAllergies(ArrayList<UsersAllergy> allergylist) {
 		ArrayList<UsersAllergy> ret = new ArrayList<>();
 		for (UsersAllergy a : allergylist) {

code/moya-beans/ejbModule/fi/codecrew/moya/beans/UserBean.java

@@ -1180,6 +1180,17 @@ public class UserBean implements UserBeanLocal {
 		return eventUser;
 	}
 
+	@Override
+	@RolesAllowed(SpecialPermission.S_USER)
+	public List<EventUser> findAllEventusers(User user) {
+		user = userFacade.reload(user);
+		if (!permbean.isCurrentUser(user) && !permbean.getCurrentUser().isSuperadmin()) {
+			throw new EJBAccessException("Only users themselves can fetch all eventusers for all events");
+
+		}
+		return eventUserFacade.findForUser(user);
+	}
+
 
 	@Override
 	@RolesAllowed(EventPermission.S_MANAGE_EVENT)

code/moya-beans/ejbModule/fi/codecrew/moya/facade/EventUserFacade.java

@@ -211,6 +211,14 @@ public class EventUserFacade extends IntegerPkGenericFacade<EventUser> {
 		return getSingleNullableResult(getEm().createQuery(cq));
 	}
 
+	public List<EventUser> findForUser(User user) {
+		CriteriaBuilder cb = getEm().getCriteriaBuilder();
+		CriteriaQuery<EventUser> cq = cb.createQuery(EventUser.class);
+		Root<EventUser> root = cq.from(EventUser.class);
+		cq.where(cb.equal(root.get(EventUser_.user), user));
+		return getEm().createQuery(cq).getResultList();
+	}
+
 	// private Predicate addAcPredicate(CriteriaBuilder cb, UserSearchQuery
 	// query, Root<AccountEvent> root) {
 	// Expression<BigDecimal> sum =

code/moya-beans/ejbModule/fi/codecrew/moya/facade/UsersAllergyFacade.java

@@ -18,10 +18,7 @@
  */
 package fi.codecrew.moya.facade;
 
-import fi.codecrew.moya.model.Allergy;
-import fi.codecrew.moya.model.EventUser;
-import fi.codecrew.moya.model.UsersAllergy;
-import fi.codecrew.moya.model.UsersAllergy_;
+import fi.codecrew.moya.model.*;
 
 import javax.ejb.LocalBean;
 import javax.ejb.Stateless;
@@ -39,12 +36,12 @@ public class UsersAllergyFacade extends IntegerPkGenericFacade<UsersAllergy> {
 	}
 
 
-	public List<UsersAllergy> findForUser(EventUser user) {
+	public List<UsersAllergy> findForUser(User user) {
 		CriteriaBuilder cb = getEm().getCriteriaBuilder();
 		CriteriaQuery<UsersAllergy> cq = cb.createQuery(UsersAllergy.class);
 		Root<UsersAllergy> root = cq.from(UsersAllergy.class);
 
-		cq.where(cb.equal(root.get(UsersAllergy_.user), user.getUser()));
+		cq.where(cb.equal(root.get(UsersAllergy_.user), user));
 
 		return getEm().createQuery(cq).getResultList();
 	}

code/moya-database/src/main/java/fi/codecrew/moya/model/LanguageAwareString.java

@@ -25,6 +25,9 @@ public class LanguageAwareString {
 		}
 		return ret;
 	}
+	public String getDefaultValue(){
+		return getValue(defaultLanguage);
+	}
 
 	public String getDefaultLanguage() {
 		return defaultLanguage;

code/moya-database/src/main/java/fi/codecrew/moya/model/UsersAllergy.java

@@ -3,34 +3,35 @@ package fi.codecrew.moya.model;
 import javax.persistence.*;
 import java.util.Date;
 
-@Table(name="user_allergies")
+@Table(name = "user_allergies")
 @Entity
 public class UsersAllergy extends GenericEntity {
 
-	@Column(nullable=false, name = "selected")
+	@Column(nullable = false, name = "selected")
 	private boolean selected = false;
 
 	@Enumerated(EnumType.STRING)
-	@Column(name="severity")
+	@Column(name = "severity")
 	private AllergySeverity severity = AllergySeverity.NORMAL;
 
 	@ManyToOne
-	@JoinColumn(name="user_id", updatable = false, referencedColumnName = "id", nullable = false)
+	@JoinColumn(name = "user_id", updatable = false, referencedColumnName = "id", nullable = false)
 	private User user;
 
 	@ManyToOne
-	@JoinColumn(name="allergy_id", updatable = false, referencedColumnName = "id", nullable = false)
+	@JoinColumn(name = "allergy_id", updatable = false, referencedColumnName = "id", nullable = false)
 	private Allergy allergy;
 
 
-	@Column(name="created")
+	@Column(name = "created")
 	@Temporal(TemporalType.TIMESTAMP)
 	private Date created;
 
 
 	@Lob
-	@Column(name="notes")
+	@Column(name = "notes")
 	private String notes;
+
 	public UsersAllergy() {
 		super();
 	}
@@ -80,4 +81,12 @@ public class UsersAllergy extends GenericEntity {
 	public void setSelected(boolean selected) {
 		this.selected = selected;
 	}
+
+	public Date getCreated() {
+		return created;
+	}
+
+	public void setCreated(Date created) {
+		this.created = created;
+	}
 }

code/moya-parent/pom.xml

@@ -170,6 +170,11 @@
 			<version>${findbugs.version}</version>
 			<scope>provided</scope>
 		</dependency>
+		<dependency>
+			<groupId>com.graphql-java</groupId>
+			<artifactId>graphql-java</artifactId>
+			<version>9.0</version>
+		</dependency>
 	</dependencies>
 	<reporting>
 		<plugins>

code/moya-web/src/main/java/fi/codecrew/moya/HostnameFilter.java

@@ -20,6 +20,7 @@ package fi.codecrew.moya;
 
 import java.io.IOException;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.security.Principal;
 import java.util.Base64;
 
@@ -185,7 +186,7 @@ public class HostnameFilter implements Filter {
 
 					if (!restAuth(httpRequest, response) && RestApplicationEntrypoint.REST_PATH.equals(httpRequest.getServletPath())) {
 						response.reset();
-						response.getOutputStream().write("Rest auth failed! ".getBytes( Charsets.UTF_8));
+						response.getOutputStream().write("Rest auth failed! ".getBytes( StandardCharsets.UTF_8));
 
 						if (response instanceof HttpServletResponse) {
 							HttpServletResponse httpResp = (HttpServletResponse) response;

code/moya-web/src/main/java/fi/codecrew/moya/graphql/AlreadyBuiltException.java

+package fi.codecrew.moya.graphql;
+
+public class AlreadyBuiltException extends RuntimeException {
+	public AlreadyBuiltException(String s) {
+		super(s);
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/EntityGQLBuilder.java

+package fi.codecrew.moya.graphql;
+
+import graphql.schema.*;
+
+import javax.persistence.metamodel.Attribute;
+import javax.persistence.metamodel.PluralAttribute;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+
+import static graphql.Scalars.*;
+import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition;
+import static graphql.schema.GraphQLObjectType.newObject;
+
+public class EntityGQLBuilder<T> {
+	private final GraphQLObjectType.Builder builder;
+
+
+	private final GraphQLBuilder parent;
+	private final String typeName;
+	private final List<GraphQLFieldDefinition.Builder> fields = new ArrayList<>();
+	private GraphQLObjectType builtObject;
+
+	public EntityGQLBuilder(String name, GraphQLBuilder bld) {
+		this.typeName = name;
+		this.parent = bld;
+		this.builder = newObject().name(name);
+
+	}
+
+	public GraphQLFieldDefinition.Builder addField() {
+		if (builtObject != null) {
+			throw new AlreadyBuiltException("This method can not be called after 'build()'-function has been called");
+		}
+		GraphQLFieldDefinition.Builder ret = newFieldDefinition();
+		fields.add(ret);
+		return ret;
+	}
+
+	public GraphQLFieldDefinition.Builder addField(Class<?> clz) {
+		return addField()
+			.type(typeForClass(clz))
+			.name(clz.getSimpleName().toLowerCase());
+
+	}
+
+	public GraphQLFieldDefinition.Builder addListField(Class<?> clz) {
+		return addField()
+			.type(GraphQLList.list(typeForClass(clz)))
+			.name((clz.getSimpleName() + "s").toLowerCase());
+	}
+
+	/**
+	 * Add a field to graphql schema from JPA metamodel.
+	 * This function will set a name and DataFetcher to the fieldDefinition builder,
+	 * which then can be overriden from the returned builder, if needed
+	 *
+	 * @param field JPA metamodel field to be added to the graphql schema
+	 * @return Field definition builder, where type, name and data fetcher are set according to the {@param field}
+	 */
+	public GraphQLFieldDefinition.Builder addField(Attribute<? super T, ?> field) {
+
+		GraphQLOutputType type = typeForClass(field.getJavaType());
+		if (field instanceof PluralAttribute) {
+			type = GraphQLList.list(typeForClass(((PluralAttribute) field).getBindableJavaType()));
+		}
+
+		return addField()
+			.type(type)
+			.name(field.getName().toLowerCase())
+			.dataFetcher(new PropertyDataFetcher<>(field.getName()));
+	}
+
+
+
+	private GraphQLOutputType typeForClass(Class<?> type) {
+
+		if (Boolean.class.isAssignableFrom(type) || boolean.class.isAssignableFrom(type)) {
+			return GraphQLBoolean;
+		}
+		if (Double.class.isAssignableFrom(type) || double.class.isAssignableFrom(type)) {
+			return GraphQLFloat;
+		}
+		if (Byte.class.isAssignableFrom(type) || byte.class.isAssignableFrom(type)) {
+			return GraphQLByte;
+		}
+		if (Character.class.isAssignableFrom(type) || char.class.isAssignableFrom(type)) {
+			return GraphQLChar;
+		}
+		if (Short.class.isAssignableFrom(type) || short.class.isAssignableFrom(type)) {
+			return GraphQLShort;
+		}
+		if (Integer.class.isAssignableFrom(type) || int.class.isAssignableFrom(type)) {
+			return GraphQLInt;
+		}
+		if (Long.class.isAssignableFrom(type) || long.class.isAssignableFrom(type)) {
+			return GraphQLLong;
+		}
+		if (BigInteger.class.isAssignableFrom(type)) {
+			return GraphQLBigInteger;
+		}
+		if (BigDecimal.class.isAssignableFrom(type)) {
+			return GraphQLBigDecimal;
+		}
+		if (String.class.isAssignableFrom(type)) {
+			return GraphQLString;
+		}
+		if (byte[].class.isAssignableFrom(type) || Byte[].class.isAssignableFrom(type)) {
+			return GraphQLUtils.GRAPHQL_BYTE_TO_BASE64_TYPE;
+		}
+		if (Enum.class.isAssignableFrom(type)) {
+			return parent.getEnum((Class<Enum>) type);
+		}
+		if (Date.class.isAssignableFrom(type)
+			|| Calendar.class.isAssignableFrom(type)
+			|| OffsetDateTime.class.isAssignableFrom(type)
+			|| LocalDateTime.class.isAssignableFrom(type)
+			|| LocalDate.class.isAssignableFrom(type)) {
+			return GraphQLUtils.GRAPHQL_DATE_TYPE;
+		}
+		return parent.typeFor(type);
+		
+	}
+
+
+	public GraphQLObjectType build() {
+		if (builtObject == null) {
+			fields.forEach(f -> builder.field(f));
+			builtObject = builder.build();
+		}
+		return builtObject;
+	}
+
+	public GraphQLObjectType.Builder getRawTypeBuilder() {
+		return builder;
+	}
+
+
+	public EntityGQLBuilder<T> description(String s) {
+		builder.description(s);
+		return this;
+	}
+
+	public GraphQLType getRef() {
+		return parent.typeFor(typeName);
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/GRPDException.java

+package fi.codecrew.moya.graphql;
+
+public class GRPDException extends RuntimeException {
+	public GRPDException(String reason) {
+		super(reason);
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/GraphQLBuilder.java

+package fi.codecrew.moya.graphql;
+
+import graphql.schema.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static graphql.schema.GraphQLEnumType.newEnum;
+
+public class GraphQLBuilder {
+	private final Map<String, EntityGQLBuilder<?>> entities = new HashMap<>();
+	private final Map<String, GraphQLEnumType> enums = new HashMap<>();
+	private final Set<String> uncheckedTypes = new HashSet<>();
+	private static final Logger logger = LoggerFactory.getLogger(GraphQLBuilder.class);
+
+	public <T> EntityGQLBuilder<T> createEntity(Class<T> entityClass) {
+		return createEntity(entityClass.getSimpleName());
+	}
+
+	public <T> EntityGQLBuilder<T> createEntity(String name) {
+		EntityGQLBuilder<T> ret = new EntityGQLBuilder<>(name, this);
+		entities.put(name, ret);
+		return ret;
+	}
+
+	public Set<GraphQLType> getTypes() {
+		Set<GraphQLType> ret = new HashSet<>(enums.values());
+		List<GraphQLObjectType> retEnt = entities.values().stream().map(v -> v.build()).collect(Collectors.toList());
+		logger.warn("Returning entities", retEnt);
+		ret.addAll(retEnt);
+		logger.warn("Enums {}, entities {}", enums, entities);
+		logger.warn("Builder returning types: {}", ret);
+		return ret;
+	}
+
+	public GraphQLTypeReference typeFor(String typeName) {
+		logger.warn("Adding typeFor: {}", typeName);
+		if (!entities.containsKey(typeName) && !enums.containsKey(typeName)) {
+			logger.warn("Adding unknown type: this might be an error!"+ typeName, new RuntimeException().fillInStackTrace());
+			uncheckedTypes.add(typeName);
+		}
+
+		return GraphQLTypeReference.typeRef(typeName);
+	}
+
+	public GraphQLTypeReference typeFor(Class<?> clz) {
+		return typeFor(clz.getSimpleName());
+
+	}
+
+	public <X extends Enum> GraphQLOutputType getEnum(Class<X> type) {
+		String name = type.getSimpleName();
+		if (name == null) {
+			throw new NullPointerException("Trying to get enum with type " + type);
+		}
+		if (!enums.containsKey(name)) {
+			GraphQLEnumType.Builder ret = newEnum().name(name);
+			for (Enum c : type.getEnumConstants()) {
+				ret.value(c.name());
+			}
+			enums.put(name, ret.build());
+		}
+		return typeFor(type);
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/GraphQLUtils.java

+package fi.codecrew.moya.graphql;
+
+import graphql.schema.*;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.*;
+import java.time.format.DateTimeFormatter;
+import java.util.Base64;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+public class GraphQLUtils {
+
+	public static final GraphQLScalarType GRAPHQL_BYTE_TO_BASE64_TYPE = new GraphQLScalarType("Base64Data", "Binary data in base64 format", new Coercing<byte[], String>() {
+
+		@Override
+		public String serialize(Object dataFetcherResult) throws CoercingSerializeException {
+			byte[] data = (byte[]) dataFetcherResult;
+			if (data == null || data.length == 0) {
+				return "";
+			}
+			return Base64.getEncoder().encodeToString(data);
+		}
+
+		@Override
+		public byte[] parseValue(Object input) throws CoercingParseValueException {
+			return Base64.getDecoder().decode(input.toString());
+		}
+
+		@Override
+		public byte[] parseLiteral(Object input) throws CoercingParseLiteralException {
+			return Base64.getDecoder().decode(input.toString());
+		}
+	});
+
+
+	public static final GraphQLScalarType GRAPHQL_DATE_TYPE = new GraphQLScalarType("Date", "Date in ISO-8601 format: yyyymmddThhmmssZ (for example: 2011-12-03T10:15:30Z')", new Coercing<Object, String>() {
+
+
+		@Override
+		public String serialize(Object dataFetcherResult) throws CoercingSerializeException {
+			if (dataFetcherResult == null) {
+				return null;
+			}
+			try {
+				if (dataFetcherResult instanceof Date) {
+					return Instant
+						.ofEpochMilli(((Date) dataFetcherResult).getTime())
+						.atZone(ZoneId.systemDefault())
+						.toOffsetDateTime()
+						.format(DateTimeFormatter.ISO_INSTANT);
+				} else if (dataFetcherResult instanceof Calendar) {
+					return Instant
+						.ofEpochMilli(((Calendar) dataFetcherResult).getTime().getTime())
+						.atZone(ZoneId.systemDefault())
+						.toOffsetDateTime()
+						.format(DateTimeFormatter.ISO_INSTANT);
+				} else if (dataFetcherResult instanceof OffsetDateTime) {
+					return ((OffsetDateTime) dataFetcherResult).format(DateTimeFormatter.ISO_INSTANT);
+				} else if (dataFetcherResult instanceof LocalDateTime) {
+					return ((LocalDateTime) dataFetcherResult).format(DateTimeFormatter.ISO_INSTANT);
+				} else if (dataFetcherResult instanceof LocalDate) {
+					return ((LocalDate) dataFetcherResult).format(DateTimeFormatter.ISO_INSTANT);
+				}
+			} catch (Exception e) {
+				throw new CoercingSerializeException("Error converting detected  dateformat: " + dataFetcherResult, e);
+			}
+
+			throw new CoercingSerializeException("Unknonw date type " + dataFetcherResult.getClass());
+
+		}
+
+		@Override
+		public Object parseValue(Object input) throws CoercingParseValueException {
+			throw new UnsupportedOperationException("Not yet implemented... TODO... ");
+		}
+
+		@Override
+		public Object parseLiteral(Object input) throws CoercingParseLiteralException {
+			throw new UnsupportedOperationException("Not yet implemented... TODO... ");
+		}
+	});
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/util/DataFetchingEnvironmentWrapper.java

+package fi.codecrew.moya.graphql.util;
+
+import graphql.execution.ExecutionContext;
+import graphql.execution.ExecutionId;
+import graphql.execution.ExecutionTypeInfo;
+import graphql.language.Field;
+import graphql.language.FragmentDefinition;
+import graphql.schema.*;
+
+import java.util.List;
+import java.util.Map;
+
+public class DataFetchingEnvironmentWrapper<SRCT> implements DataFetchingEnvironment {
+	private final SRCT source;
+	private final DataFetchingEnvironment env;
+
+	public DataFetchingEnvironmentWrapper(DataFetchingEnvironment environment, SRCT source) {
+		this.env = environment;
+		this.source = source;
+	}
+
+	@Override
+	public SRCT getSource() {
+		return source;
+	}
+
+	@Override
+	public Map<String, Object> getArguments() {
+		return env.getArguments();
+	}
+
+	@Override
+	public boolean containsArgument(String name) {
+		return env.containsArgument(name);
+	}
+
+	@Override
+	public <T> T getArgument(String name) {
+		return env.getArgument(name);
+	}
+
+	@Override
+	public <T> T getContext() {
+		return env.getContext();
+	}
+
+	@Override
+	public <T> T getRoot() {
+		return env.getRoot();
+	}
+
+	@Override
+	public GraphQLFieldDefinition getFieldDefinition() {
+		return env.getFieldDefinition();
+	}
+
+	@Override
+	public List<Field> getFields() {
+		return env.getFields();
+	}
+
+	@Override
+	public Field getField() {
+		return env.getField();
+	}
+
+	@Override
+	public GraphQLOutputType getFieldType() {
+		return env.getFieldType();
+	}
+
+	@Override
+	public ExecutionTypeInfo getFieldTypeInfo() {
+		return env.getFieldTypeInfo();
+	}
+
+	@Override
+	public GraphQLType getParentType() {
+		return env.getParentType();
+	}
+
+	@Override
+	public GraphQLSchema getGraphQLSchema() {
+		return env.getGraphQLSchema();
+	}
+
+	@Override
+	public Map<String, FragmentDefinition> getFragmentsByName() {
+		return env.getFragmentsByName();
+	}
+
+	@Override
+	public ExecutionId getExecutionId() {
+		return env.getExecutionId();
+	}
+
+	@Override
+	public DataFetchingFieldSelectionSet getSelectionSet() {
+		return env.getSelectionSet();
+	}
+
+	@Override
+	public ExecutionContext getExecutionContext() {
+		return env.getExecutionContext();
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/util/JSONPropertyDataFetcher.java

+package fi.codecrew.moya.graphql.util;
+
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.PropertyDataFetcher;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.json.JsonObject;
+
+public class JSONPropertyDataFetcher implements DataFetcher<String> {
+
+	private static final Logger logger = LoggerFactory.getLogger(JSONPropertyDataFetcher.class);
+	private final PropertyDataFetcher<JsonObject> fetcher;
+	private final String[] path;
+
+	public JSONPropertyDataFetcher(String field, String... path) {
+		fetcher = new PropertyDataFetcher<>(field);
+		this.path = path;
+	}
+
+	@Override
+	public String get(DataFetchingEnvironment environment) {
+		JsonObject obj = fetcher.get(environment);
+		for (int i = 0; i < path.length; ++i) {
+			if (obj == null || !obj.containsKey(path[i])) {
+				logger.debug("Json Object null, or key null {}, path {}", obj, path[i] );
+				return null;
+			}
+			if(i + 1 == path.length){
+				return obj.getString(path[i]);
+			} else {
+				obj = obj.getJsonObject(path[i]);
+			}
+		}
+		return null;
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/graphql/util/PropertyFetchWrapper.java

+package fi.codecrew.moya.graphql.util;
+
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.PropertyDataFetcher;
+
+public class PropertyFetchWrapper<T, INNER> implements DataFetcher<T> {
+	private final DataFetcher<INNER> fetcher;
+	private final DataFetcher<T> innerFetcher;
+
+	public PropertyFetchWrapper(String field, DataFetcher<T> innerFetcher) {
+		this.fetcher = new PropertyDataFetcher<>(field);
+		this.innerFetcher = innerFetcher;
+	}
+
+	@Override
+	public T get(DataFetchingEnvironment environment) {
+		INNER field = fetcher.get(environment);
+		return innerFetcher.get(new DataFetchingEnvironmentWrapper(environment, field));
+	}
+}

code/moya-web/src/main/java/fi/codecrew/moya/rest/v2/PojoFactoryV2.java

@@ -22,7 +22,7 @@ public class PojoFactoryV2 implements Serializable {
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public UserPojo createUserPojo(EventUser eventUser) {
+	public static UserPojo createUserPojo(EventUser eventUser) {
         User user = eventUser.getUser();
         UserPojo pojo = new UserPojo();
         pojo.eventuserId = eventUser.getId();