Java Code Examples for graphql.schema.DataFetchingEnvironment#getSource()

@Override
public TypedValue get(DataFetchingEnvironment env) {
  if (env.getSource() instanceof SubjectReference) {
    SubjectReference source = env.getSource();
    DataSet dataSet = source.getDataSet();

    if (env.getParentType() instanceof GraphQLObjectType) {
      String type = getDirectiveArgument((GraphQLObjectType) env.getParentType(), "rdfType", "uri").orElse(null);

      Optional<TypedValue> summaryProperty = summaryPropDataRetriever.createSummaryProperty(source, dataSet, type);
      if (summaryProperty.isPresent()) {
        return summaryProperty.get();
      }
    }

    // fallback to the uri if no summary props can be found for the title
    return TypedValue.create(source.getSubjectUri(), STRING, dataSet);

  }
  return null;
}
 

@Override
public Object get(DataFetchingEnvironment env) {
  SubjectReference source = env.getSource();
  final DataSet dataSet = source.getDataSet();
  final QuadStore qs = dataSet.getQuadStore();
  final Map<String, Type> schema = dataSet.getSchemaStore().getStableTypes();
  final TypeNameStore typeNameStore = dataSet.getTypeNameStore();
  try (Stream<CursorQuad> quads = qs.getQuads(source.getSubjectUri(), HAS_VIEW_CONFIG, Direction.OUT, "")) {
    return quads.findFirst().flatMap(q -> {
      try {
        return Optional.ofNullable(objectMapper.readValue(q.getObject(), List.class));
      } catch (IOException e) {
        LOG.error("view config is not a valid JSON object", e);
        return Optional.empty();
      }
    }).orElseGet(() -> makeDefaultViewConfig(source.getSubjectUri(), schema, typeNameStore));
  }
}
 

public ResolutionEnvironment(Resolver resolver, DataFetchingEnvironment env, ValueMapper valueMapper, GlobalEnvironment globalEnvironment,
                             ConverterRegistry converters, DerivedTypeRegistry derivedTypes) {

    this.context = env.getSource();
    this.rootContext = env.getContext();
    this.resolver = resolver;
    this.valueMapper = valueMapper;
    this.globalEnvironment = globalEnvironment;
    this.converters = converters;
    this.fieldType = env.getFieldType();
    this.parentType = (GraphQLNamedType) env.getParentType();
    this.graphQLSchema = env.getGraphQLSchema();
    this.dataFetchingEnvironment = env;
    this.derivedTypes = derivedTypes;
    this.arguments = new HashMap<>();
}
 

@Batched
@Override
public Object get(DataFetchingEnvironment env) {
    List<Object> unresolved = new ArrayList<>();
    Object result;
    int depth = listDepth;
    if ( env.getSource() instanceof List ) { // batched.
        result = getBatched(env);
        if ( null != resolver ) addUnresolved(unresolved, result, ++depth);
    } else {
        result = getUnbatched(env);
        if ( null != resolver ) addUnresolved(unresolved, result, depth);
    }
    if ( null == resolver ) return result;
    return replaceResolved(result, resolver.resolve(unresolved).iterator(), depth);
}
 

@Override
public TypedValue get(DataFetchingEnvironment env) {
  if (env.getSource() instanceof SubjectReference) {
    SubjectReference source = env.getSource();
    DataSet dataSet = source.getDataSet();

    if (env.getParentType() instanceof GraphQLObjectType) {
      String type = getDirectiveArgument((GraphQLObjectType) env.getParentType(), "rdfType", "uri").orElse(null);

      Optional<TypedValue> summaryProperty = summaryPropDataRetriever.createSummaryProperty(source, dataSet, type);
      if (summaryProperty.isPresent()) {
        return summaryProperty.get();
      }
    }
  }
  return null;
}
 

@Override
public Object get(DataFetchingEnvironment env) {
    Object source = ( null != impl ) ? impl : env.getSource();
    if (source == null) return null;
    if (source instanceof ResolveDataFetchingEnvironment) {
        source = ((ResolveDataFetchingEnvironment)source).resolve(env);
    }
    return getMethodViaGetter(source, env.getFieldType(), getFieldType(env.getParentType()), env.getArguments());
}
 

@Override
public List<LogEntryImportStatus> get(DataFetchingEnvironment env) {
  User currentUser = env.<ContextData>getContext().getUser()
                                                  .orElseThrow(() -> new RuntimeException("You are not logged in"));

  DataSetMetaData dataSetMetaData = env.getSource();

  MutationHelpers.checkPermission(env, dataSetMetaData, Permission.READ_IMPORT_STATUS);

  DataSetMetaData input = env.getSource();
  Optional<DataSet> dataSetOpt = dataSetRepository.getDataSet(
    currentUser,
    input.getOwnerId(),
    input.getDataSetId()
  );

  return dataSetOpt.map(dataSet -> dataSet.getImportManager().getLogList())
                   .map(logList -> {
                     final int[] num = new int[]{0};
                     return logList.getEntries().stream().map(logEntry -> {
                       Iterable<LogEntry> unprocessedEntries = logList::getUnprocessed;
                       boolean unprocessed = stream(unprocessedEntries.spliterator(), false)
                         .anyMatch(unprocessedEntry -> unprocessedEntry.equals(logEntry));
                       return new LogEntryImportStatus(logEntry, num[0]++, unprocessed);
                     }).collect(toList());
                   }).orElse(Lists.newArrayList());
}
 

@Override
public Map<String, SummaryProp> get(DataFetchingEnvironment env) {
  HashMap<String, SummaryProp> summaryPropsMap = new HashMap<>();
  if (env.getSource() instanceof SubjectReference) {
    SubjectReference source = env.getSource();
    DataSet dataSet = source.getDataSet();
    QuadStore quadStore = dataSet.getQuadStore();
    summaryPropsMap.put("title", getData(source, quadStore, RdfConstants.TIM_SUMMARYTITLEPREDICATE));
    summaryPropsMap.put("description", getData(source, quadStore, RdfConstants.TIM_SUMMARYDESCRIPTIONPREDICATE));
    summaryPropsMap.put("image", getData(source, quadStore, RdfConstants.TIM_SUMMARYIMAGEPREDICATE));

  }
  return summaryPropsMap;
}
 

@Override
public Object get(DataFetchingEnvironment environment) {
  final DatabaseResult source = environment.getSource();
  ParsedURI baseUri = new ParsedURI(source.getDataSet().getMetadata().getBaseUri());
  String uri = environment.getArgument(uriArgument);
  return lookUpSubjectByUriFetcher.getItem(
    baseUri.resolve(uri).toString(),
    source.getDataSet()
  );
}
 

/**
 * {@inheritDoc}
 */
@Override
public Object doGet(final DataFetchingEnvironment environment) {
    String fieldName = environment.getField().getName();
    Map<String, Object> source = environment.getSource();
    if (source.containsKey(fieldName) && nonNull(source.get(fieldName))) {
        String transformerName = environment.getArgument(ARG_NAME_TRANSFORM);
        if (isNotEmpty(transformerName)) {
            return urlTransformationService.transform(transformerName, source.get(fieldName).toString());
        }
    }
    return source.get(fieldName);
}
 

@Override
public PaginatedDynamicList get(DataFetchingEnvironment environment) {
  if (environment.getSource() instanceof SubjectReference) {
    SubjectReference source = environment.getSource();
    PaginationArguments arguments = argumentsHelper.getPaginationArguments(environment);
    DataSet dataSet = ((DatabaseResult) environment.getSource()).getDataSet();
    String cursor = arguments.getCursor();
    String predicate = environment.getArgument("uri");
    Direction direction = environment.getArgument("outgoing") ? OUT : IN;

    try (Stream<CursorQuad> q = dataSet.getQuadStore()
      .getQuads(source.getSubjectUri(), predicate, direction, cursor)) {
      final PaginatedList<DatabaseResult> paginatedList = getPaginatedList(
        q,
        qd -> this.makeItem(qd, dataSet),
        arguments,
        Optional.empty()
      );
      return PaginatedDynamicList.create(
        paginatedList.getPrevCursor(),
        paginatedList.getNextCursor(),
        paginatedList.getItems()
      );
    }
  } else {
    return PaginatedDynamicList.create(
      Optional.empty(),
      Optional.empty(),
      Lists.newArrayList()
    );
  }
}
 

public FetchParams(DataFetchingEnvironment environment, HGQLSchema hgqlschema) {

        subjectResource = environment.getSource();
        String predicate = ((Field) environment.getFields().toArray()[0]).getName();
        predicateURI = hgqlschema.getFields().get(predicate).getId();
        client = environment.getContext();
        if (!environment.getParentType().getName().equals("Query")) {
            String targetName = hgqlschema.getTypes().get(environment.getParentType().getName()).getField(predicate).getTargetName();
            if (hgqlschema.getTypes().containsKey(targetName) && hgqlschema.getTypes().get(targetName).getId()!=null) {
                targetURI=hgqlschema.getTypes().get(targetName).getId();
            }
        }
    }
 

@Override
public ProductDto get(DataFetchingEnvironment environment) {
    log.info("getSource {}", (Object)environment.getSource());
    OrderItemDto orderItemDto = environment.getSource();
    ProductDto product = productAdaptor.getProduct(orderItemDto.getProductId());
    return product;
}
 

@Override
public UserDto get(DataFetchingEnvironment environment) {
    log.info("getSource {}", (Object) environment.getSource());
    OrderDto order = environment.getSource();
    UserDto user = userAdaptor.getUser(order.getUserId());
    return user;
}
 

@Override
public Object get(DataFetchingEnvironment environment) throws Exception {

  final Object source = environment.getSource();
  if (source == null) {
    return null;
  }

  if (source instanceof Message) {
    GraphQLType type = environment.getFieldType();
    if (type instanceof GraphQLEnumType) {
      return ((Message) source).getField(fieldDescriptor).toString();
    }
    return ((Message) source).getField(fieldDescriptor);
  }
  if (environment.getSource() instanceof Map) {
    return ((Map<?, ?>) source).get(convertedFieldName);
  }

  if (method == null) {
    // no synchronization necessary because this line is idempotent
    final String methodNameSuffix =
        fieldDescriptor.isMapField() ? "Map" : fieldDescriptor.isRepeated() ? "List" : "";
    final String methodName =
        "get" + LOWER_CAMEL_TO_UPPER.convert(convertedFieldName) + methodNameSuffix;
    method = source.getClass().getMethod(methodName);
  }
  return method.invoke(source);
}
 

public FetchParams(DataFetchingEnvironment environment, HGQLSchema hgqlSchema)
        throws HGQLConfigurationException {

    final String predicate = extractPredicate(environment);
    predicateURI = extractPredicateUri(hgqlSchema, predicate);
    targetURI = extractTargetURI(environment, hgqlSchema, predicate);
    subjectResource = environment.getSource();
    client = environment.getContext();
}
 

@Override
public Object get(DataFetchingEnvironment environment) {
    if (environment.getSource() == null) return null;
    return environment.getSource().toString();
}
 

private Object getLinkPostedBy(DataFetchingEnvironment env) {
  Link link = env.getSource();
  DataLoader<String, User> user = env.getDataLoader("user");
  return user.load(link.getUserId());
}
 

private Object getLinkPostedBy(DataFetchingEnvironment env) {
  Link link = env.getSource();
  DataLoader<String, User> user = env.getDataLoader("user");
  return user.load(link.getUserId());
}
 

public Author author(DataFetchingEnvironment dfe) {
    Book book = dfe.getSource();
    return mapAuthors.get(book.getAuthorId());
}