コード例 #1
0
  @Override
  public final BaseResponse<?> handle(
      JsonPath jsonPath, RequestParams requestParams, RequestBody requestBody) throws Exception {
    String resourceName = jsonPath.getResourceName();
    PathIds resourceIds = jsonPath.getIds();
    RegistryEntry registryEntry = resourceRegistry.getEntry(resourceName);

    if (registryEntry == null) {
      throw new ResourceNotFoundException(resourceName);
    }
    if (requestBody == null) {
      throw new RequestBodyNotFoundException(HttpMethod.POST, resourceName);
    }

    Serializable castedResourceId = getResourceId(resourceIds, registryEntry);
    ResourceField relationshipField =
        registryEntry
            .getResourceInformation()
            .findRelationshipFieldByName(jsonPath.getElementName());
    if (relationshipField == null) {
      throw new ResourceFieldNotFoundException(jsonPath.getElementName());
    }
    ResourceRepository resourceRepository = registryEntry.getResourceRepository();
    @SuppressWarnings("unchecked")
    Object resource = resourceRepository.findOne(castedResourceId, requestParams);

    Class<?> baseRelationshipFieldClass = relationshipField.getType();
    Class<?> relationshipFieldClass =
        Generics.getResourceClass(relationshipField.getGenericType(), baseRelationshipFieldClass);
    @SuppressWarnings("unchecked")
    Class<? extends Serializable> relationshipIdType =
        (Class<? extends Serializable>)
            resourceRegistry
                .getEntry(relationshipFieldClass)
                .getResourceInformation()
                .getIdField()
                .getType();

    RelationshipRepository relationshipRepositoryForClass =
        registryEntry.getRelationshipRepositoryForClass(relationshipFieldClass);
    if (Iterable.class.isAssignableFrom(baseRelationshipFieldClass)) {
      if (!requestBody.isMultiple()) {
        throw new RequestBodyException(HttpMethod.POST, resourceName, "Non-multiple data in body");
      }
      Iterable<DataBody> dataBodies = requestBody.getMultipleData();
      processToManyRelationship(
          resource,
          relationshipIdType,
          jsonPath.getElementName(),
          dataBodies,
          relationshipRepositoryForClass);
    } else {
      if (requestBody.isMultiple()) {
        throw new RequestBodyException(HttpMethod.POST, resourceName, "Multiple data in body");
      }
      DataBody dataBody = requestBody.getSingleData();
      processToOneRelationship(
          resource,
          relationshipIdType,
          jsonPath.getElementName(),
          dataBody,
          relationshipRepositoryForClass);
    }

    MetaInformation metaInformation =
        getMetaInformation(resourceRepository, Collections.singletonList(resource), requestParams);

    return new ResourceResponse(metaInformation);
  }
コード例 #2
0
  @Test
  public void onExistingToOneRelationshipShouldRemoveIt() throws Exception {
    // GIVEN
    RequestBody newTaskBody = new RequestBody();
    DataBody data = new DataBody();
    newTaskBody.setData(data);
    data.setType("tasks");
    data.setAttributes(OBJECT_MAPPER.createObjectNode().put("name", "sample task"));
    data.setRelationships(new ResourceRelationships());

    JsonPath taskPath = pathBuilder.buildPath("/tasks");
    ResourcePost resourcePost = new ResourcePost(resourceRegistry, typeParser, OBJECT_MAPPER);

    // WHEN -- adding a task
    BaseResponseContext taskResponse =
        resourcePost.handle(taskPath, new QueryParams(), null, newTaskBody);

    // THEN
    assertThat(taskResponse.getResponse().getEntity()).isExactlyInstanceOf(Task.class);
    Long taskId = ((Task) (taskResponse.getResponse().getEntity())).getId();
    assertThat(taskId).isNotNull();

    /* ------- */

    // GIVEN
    RequestBody newProjectBody = new RequestBody();
    data = new DataBody();
    newProjectBody.setData(data);
    data.setType("projects");
    data.setAttributes(OBJECT_MAPPER.createObjectNode().put("name", "sample project"));

    JsonPath projectPath = pathBuilder.buildPath("/projects");

    // WHEN -- adding a project
    ResourceResponseContext projectResponse =
        resourcePost.handle(projectPath, new QueryParams(), null, newProjectBody);

    // THEN
    assertThat(projectResponse.getResponse().getEntity()).isExactlyInstanceOf(Project.class);
    assertThat(((Project) (projectResponse.getResponse().getEntity())).getId()).isNotNull();
    assertThat(((Project) (projectResponse.getResponse().getEntity())).getName())
        .isEqualTo("sample project");
    Long projectId = ((Project) (projectResponse.getResponse().getEntity())).getId();
    assertThat(projectId).isNotNull();

    /* ------- */

    // GIVEN
    RequestBody newTaskToProjectBody = new RequestBody();
    data = new DataBody();
    newTaskToProjectBody.setData(data);
    data.setType("projects");
    data.setId(projectId.toString());

    JsonPath savedTaskPath = pathBuilder.buildPath("/tasks/" + taskId + "/relationships/project");
    RelationshipsResourcePost relationshipsResourcePost =
        new RelationshipsResourcePost(resourceRegistry, typeParser);

    // WHEN -- adding a relation between task and project
    BaseResponseContext projectRelationshipResponse =
        relationshipsResourcePost.handle(
            savedTaskPath, new QueryParams(), null, newTaskToProjectBody);
    assertThat(projectRelationshipResponse).isNotNull();

    // THEN
    TaskToProjectRepository taskToProjectRepository = new TaskToProjectRepository();
    Project project = taskToProjectRepository.findOneTarget(taskId, "project", REQUEST_PARAMS);
    assertThat(project.getId()).isEqualTo(projectId);

    /* ------- */

    // GIVEN
    RelationshipsResourceDelete sut = new RelationshipsResourceDelete(resourceRegistry, typeParser);

    // WHEN -- removing a relation between task and project
    BaseResponseContext result =
        sut.handle(savedTaskPath, new QueryParams(), null, newTaskToProjectBody);
    assertThat(result).isNotNull();

    // THEN
    assertThat(result.getHttpStatus()).isEqualTo(HttpStatus.NO_CONTENT_204);
    Project nullProject = taskToProjectRepository.findOneTarget(taskId, "project", REQUEST_PARAMS);
    assertThat(nullProject).isNull();
  }