How to use

org.sonatype.plexus.rest.resource.PlexusResourceException

constructor

  protected void validateUserContainment( User user )
    throws ResourceException
  {
    if ( user.getRoles().size() == 0 )
    {
      throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
                        getErrorResponse( "roles", "User requires one or more roles." ) );
    }
  }
}

 protected void validateUserContainment(User user)
   throws ResourceException
 {
  if (user.getRoles().size() == 0) {
   throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
     getErrorResponse("roles", "User requires one or more roles."));
  }
 }
}

public void validateRoleContainment(Role role)
  throws ResourceException
{
 if (role.getRoles().size() == 0 && role.getPrivileges().size() == 0) {
  throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
    getErrorResponse("privileges",
      "One or more roles/privilegs are required."));
 }
}

public void validateRoleContainment( Role role )
  throws ResourceException
{
  if ( role.getRoles().size() == 0 && role.getPrivileges().size() == 0 )
  {
    throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
                      getErrorResponse( "privileges",
                               "One or more roles/privilegs are required." ) );
  }
}

protected boolean validateFields(UserResource resource, Representation representation)
  throws PlexusResourceException
{
 if (resource.getRoles() == null || resource.getRoles().size() == 0) {
  getLogger().info("The userId (" + resource.getUserId() + ") cannot have 0 roles!");
  throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, ROLE_VALIDATION_ERROR,
    getErrorResponse("users", ROLE_VALIDATION_ERROR));
 }
 return true;
}

private PlexusResourceException logAndWrapNoSuchGroupRepositoryException(final RepositoryGroupResource model,
                                     final NoSuchRepositoryException e)
{
 getLogger().warn("Group repository does not exist, ID=" + model.getId(), e);
 return new PlexusResourceException(
   Status.CLIENT_ERROR_BAD_REQUEST,
   "Group repository does not exist, GroupId=" + model.getId(),
   e,
   getNexusErrorResponse("repositories", "Group repository does not exist"));
}

protected boolean validateFields( UserResource resource, Representation representation )
  throws PlexusResourceException
{
  if ( resource.getRoles() == null || resource.getRoles().size() == 0 )
  {
    getLogger().info( "The userId (" + resource.getUserId() + ") cannot have 0 roles!" );
    throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, ROLE_VALIDATION_ERROR,
                      getErrorResponse( "users", ROLE_VALIDATION_ERROR ) );
  }
  return true;
}

protected void handleInvalidConfigurationException(InvalidConfigurationException e)
  throws PlexusResourceException
{
 getLogger().debug("Configuration error!", e);
 ErrorResponse errorResponse;
 ValidationResponse vr = e.getValidationResponse();
 if (vr != null && vr.getValidationErrors().size() > 0) {
  ValidationMessage vm = vr.getValidationErrors().get(0);
  errorResponse = getErrorResponse(vm.getKey(), vm.getShortMessage());
 }
 else {
  errorResponse = getErrorResponse("*", e.getMessage());
 }
 throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", errorResponse);
}

protected void handleInvalidConfigurationException(InvalidConfigurationException e)
  throws PlexusResourceException
{
 getLogger().debug("Configuration error!", e);
 ErrorResponse nexusErrorResponse;
 ValidationResponse vr = e.getValidationResponse();
 if (vr != null && vr.getValidationErrors().size() > 0) {
  org.sonatype.configuration.validation.ValidationMessage vm = vr.getValidationErrors().get(0);
  nexusErrorResponse = getNexusErrorResponse(vm.getKey(), vm.getShortMessage());
 }
 else {
  nexusErrorResponse = getNexusErrorResponse("*", e.getMessage());
 }
 throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse);
}

protected void handleValidationResponse(ValidationResponse validationResponse)
  throws PlexusResourceException
{
 ErrorResponse nexusErrorResponse = new ErrorResponse();
 if (validationResponse != null && validationResponse.getValidationErrors().size() > 0) {
  for (ValidationMessage vm : validationResponse.getValidationErrors()) {
   nexusErrorResponse.addError(createNexusError(vm.getKey(), vm.getShortMessage()));
  }
  throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
    nexusErrorResponse);
 }
}

private static <E> PlexusResourceException validationError( String name, Class<E> enumClass )
{
  ErrorMessage err = new ErrorMessage();
  err.setId( "*" );
  err.setMsg( "No enum const " + enumClass + "." + name );
  ErrorResponse ner = new ErrorResponse();
  ner.addError( err );
  return new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", ner );
}

private static <E> PlexusResourceException validationError(String name, Class<E> enumClass) {
 ErrorMessage err = new ErrorMessage();
 err.setId("*");
 err.setMsg("No enum const " + enumClass + "." + name);
 ErrorResponse ner = new ErrorResponse();
 ner.addError(err);
 return new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", ner);
}

protected void handleConfigurationException(ConfigurationException e)
  throws PlexusResourceException
{
 getLogger().debug("Configuration error!", e);
 ErrorResponse nexusErrorResponse;
 if (InvalidConfigurationException.class.isAssignableFrom(e.getClass())) {
  ValidationResponse vr = ((InvalidConfigurationException) e).getValidationResponse();
  if (vr != null && vr.getValidationErrors().size() > 0) {
   ValidationMessage vm = vr.getValidationErrors().get(0);
   nexusErrorResponse = getNexusErrorResponse(vm.getKey(), vm.getShortMessage());
  }
  else {
   nexusErrorResponse = getNexusErrorResponse("*", e.getMessage());
  }
 }
 else {
  nexusErrorResponse = getNexusErrorResponse("*", e.getMessage());
 }
 throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse);
}

protected void handleInvalidConfigurationException( InvalidConfigurationException e )
  throws PlexusResourceException
{
  getLogger().warn( "Configuration error!", e );
  ErrorResponse errorResponse;
  ValidationResponse vr = e.getValidationResponse();
  if ( vr != null && vr.getValidationErrors().size() > 0 )
  {
    ValidationMessage vm = vr.getValidationErrors().get( 0 );
    errorResponse = getErrorResponse( vm.getKey(), vm.getShortMessage() );
  }
  else
  {
    errorResponse = getErrorResponse( "*", e.getMessage() );
  }
  throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", errorResponse );
}

protected void handleValidationResponse( ValidationResponse validationResponse )
  throws PlexusResourceException
{
  ErrorResponse nexusErrorResponse = new ErrorResponse();
  if ( validationResponse != null && validationResponse.getValidationErrors().size() > 0 )
  {
    for ( ValidationMessage vm : validationResponse.getValidationErrors() )
    {
      nexusErrorResponse.addError( createNexusError( vm.getKey(), vm.getShortMessage() ) );
    }
    throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.",
      nexusErrorResponse );
  }
}

protected void handleConfigurationException( ConfigurationException e )
  throws PlexusResourceException
{
  getLogger().warn( "Configuration error!", e );
  ErrorResponse nexusErrorResponse;
  if ( InvalidConfigurationException.class.isAssignableFrom( e.getClass() ) )
  {
    ValidationResponse vr = ( (InvalidConfigurationException) e ).getValidationResponse();
    if ( vr != null && vr.getValidationErrors().size() > 0 )
    {
      ValidationMessage vm = vr.getValidationErrors().get( 0 );
      nexusErrorResponse = getNexusErrorResponse( vm.getKey(), vm.getShortMessage() );
    }
    else
    {
      nexusErrorResponse = getNexusErrorResponse( "*", e.getMessage() );
    }
  }
  else
  {
    nexusErrorResponse = getNexusErrorResponse( "*", e.getMessage() );
  }
  throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse );
}

protected void handleInvalidConfigurationException( InvalidConfigurationException e )
  throws PlexusResourceException
{
  getLogger().warn( "Configuration error!", e );
  ErrorResponse nexusErrorResponse;
  ValidationResponse vr = e.getValidationResponse();
  if ( vr != null && vr.getValidationErrors().size() > 0 )
  {
    org.sonatype.configuration.validation.ValidationMessage vm = vr.getValidationErrors().get( 0 );
    nexusErrorResponse = getNexusErrorResponse( vm.getKey(), vm.getShortMessage() );
  }
  else
  {
    nexusErrorResponse = getNexusErrorResponse( "*", e.getMessage() );
  }
  throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse );
}

protected void handleConfigurationException(InvalidConfigurationException e)
  throws PlexusResourceException
{
 getLogger().debug("Configuration error!", e);
 ErrorResponse nexusErrorResponse = new ErrorResponse();
 ValidationResponse vr = ((InvalidConfigurationException) e).getValidationResponse();
 if (vr != null && vr.getValidationErrors().size() > 0) {
  for (ValidationMessage vm : vr.getValidationErrors()) {
   nexusErrorResponse.addError(createNexusError(vm.getKey(), vm.getShortMessage()));
  }
 }
 else {
  nexusErrorResponse.addError(createNexusError("*", e.getMessage()));
 }
 throw new PlexusResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse);
}

protected void handleConfigurationException( InvalidConfigurationException e )
  throws PlexusResourceException
{
  getLogger().warn( "Configuration error!", e );
  ErrorResponse nexusErrorResponse = new ErrorResponse();
  ValidationResponse vr = ( (InvalidConfigurationException) e ).getValidationResponse();
  if ( vr != null && vr.getValidationErrors().size() > 0 )
  {
    for ( ValidationMessage vm : vr.getValidationErrors() )
    {
      nexusErrorResponse.addError( createNexusError( vm.getKey(), vm.getShortMessage() ) );
    }
  }
  else
  {
    nexusErrorResponse.addError( createNexusError( "*", e.getMessage() ) );
  }
  throw new PlexusResourceException( Status.CLIENT_ERROR_BAD_REQUEST, "Configuration error.", nexusErrorResponse );
}

/**
 * Add a new repository group to nexus.
 */
@Override
@POST
@ResourceMethodSignature(input = RepositoryGroupResourceResponse.class,
  output = RepositoryGroupResourceResponse.class)
public Object post(Context context, Request request, Response response, Object payload)
  throws ResourceException
{
 RepositoryGroupResourceResponse groupRequest = (RepositoryGroupResourceResponse) payload;
 if (groupRequest != null) {
  RepositoryGroupResource resource = groupRequest.getData();
  createOrUpdateRepositoryGroup(resource, true);
  try {
   RepositoryGroupResourceResponse result = new RepositoryGroupResourceResponse();
   result.setData(buildGroupResource(request, resource.getId()));
   return result;
  }
  catch (NoSuchRepositoryException e) {
   throw new PlexusResourceException(
     Status.CLIENT_ERROR_BAD_REQUEST,
     "The group was somehow not found!",
     getNexusErrorResponse("repositories", "Group id not found!"));
  }
 }
 return null;
}