public Response getEntitySet()

in fit/src/main/java/org/apache/olingo/fit/Services.java [698:795]
76 lines of code
14 McCabe index (conditional complexity)

  public Response getEntitySet(@Context final UriInfo uriInfo,
      @HeaderParam("Accept") @DefaultValue(StringUtils.EMPTY) final String accept,
      @PathParam("name") final String name,
      @QueryParam("$top") @DefaultValue(StringUtils.EMPTY) final String top,
      @QueryParam("$skip") @DefaultValue(StringUtils.EMPTY) final String skip,
      @QueryParam("$format") @DefaultValue(StringUtils.EMPTY) final String format,
      @QueryParam("$count") @DefaultValue(StringUtils.EMPTY) final String count,
      @QueryParam("$filter") @DefaultValue(StringUtils.EMPTY) final String filter,
      @QueryParam("$orderby") @DefaultValue(StringUtils.EMPTY) final String orderby,
      @QueryParam("$skiptoken") @DefaultValue(StringUtils.EMPTY) final String skiptoken,
      @PathParam("type") final String type) {

    try {
      final Accept acceptType;
      if (StringUtils.isNotBlank(format)) {
        acceptType = Accept.valueOf(format.toUpperCase());
      } else {
        acceptType = Accept.parse(accept);
      }

      final String location = uriInfo.getRequestUri().toASCIIString();
      try {
        // search for function ...
        final InputStream func = FSManager.instance().readFile(name, acceptType);
        return xml.createResponse(location, func, null, acceptType);
      } catch (NotFoundException e) {
        if (acceptType == Accept.XML || acceptType == Accept.TEXT) {
          throw new UnsupportedMediaTypeException("Unsupported media type");
        }

        // search for entitySet ...
        final String basePath = name + File.separatorChar;

        final StringBuilder builder = new StringBuilder();
        builder.append(basePath);

        if (type != null) {
          builder.append(type).append(File.separatorChar);
        }

        if (StringUtils.isNotBlank(orderby)) {
          builder.append(Constants.get(ConstantKey.ORDERBY)).append(File.separatorChar).
          append(orderby).append(File.separatorChar);
        }

        if (StringUtils.isNotBlank(filter)) {
          builder.append(Constants.get(ConstantKey.FILTER)).append(File.separatorChar).
          append(filter.replaceAll("/", "."));
        } else if (StringUtils.isNotBlank(skiptoken)) {
          builder.append(Constants.get(ConstantKey.SKIP_TOKEN)).append(File.separatorChar).
          append(skiptoken);
        } else {
          builder.append(metadata.getEntitySet(name).isSingleton()
              ? Constants.get(ConstantKey.ENTITY)
                  : Constants.get(ConstantKey.FEED));
        }

        final InputStream feed = FSManager.instance().readFile(builder.toString(), Accept.ATOM);

        final ResWrap<EntityCollection> container = atomDeserializer.toEntitySet(feed);

        setInlineCount(container.getPayload(), count);

        final ByteArrayOutputStream content = new ByteArrayOutputStream();
        final OutputStreamWriter writer = new OutputStreamWriter(content, Constants.ENCODING);

        // -----------------------------------------------
        // Evaluate $skip and $top
        // -----------------------------------------------
        List<Entity> entries = new ArrayList<Entity>(container.getPayload().getEntities());

        if (StringUtils.isNotBlank(skip)) {
          entries = entries.subList(Integer.valueOf(skip), entries.size());
        }

        if (StringUtils.isNotBlank(top)) {
          entries = entries.subList(0, Integer.valueOf(top));
        }

        container.getPayload().getEntities().clear();
        container.getPayload().getEntities().addAll(entries);
        // -----------------------------------------------

        if (acceptType == Accept.ATOM) {
          atomSerializer.write(writer, container);
        } else {
          jsonSerializer.write(writer, container);
        }
        return xml.createResponse(
            location,
            new ByteArrayInputStream(content.toByteArray()),
            Commons.getETag(basePath),
            acceptType);
      }
    } catch (Exception e) {
      return xml.createFaultResponse(accept, e);
    }
  }