logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }
        }).orElse(() -> {
            throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml);
        });
        return redirect(getClass());
    }

  const rollback_commit = context.payload.head_commit.id;
  const pr_match_groups = context.payload.head_commit.message.match(/\Rollback of PR #(\d+).*/) || [];
  if (pr_match_groups.length != 2) {
    console.log(`PR Number not found in ${context.payload.head_commit.message}`);
    throw "Error extracting PR Number from commit message";
  }
  const pr_number = parseInt(pr_match_groups[1]);
  const owner = context.payload.repository.owner.name;

    boolean isError ();


    /**
     * Set error status
     */
    void error ();


    /**
     * 
     * @return the message timeout
     */
    Long getExpiration ();


    /**
     * 
     * @param exp
     *            message timeout
     */
    void setExpiration ( Long exp );


    /**
     * 
     */
    public void reset ();


    /**

    protected Object source;

    protected String longMessage;

    public AbstractMojoExecutionException(String message) {
        super(message);
    }

    public AbstractMojoExecutionException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code AbstractMojoExecutionException} exception wrapping an underlying {@code Throwable}.
     *

    public static final String ERROR = "ERROR";

    private String logLevel = INFO;

    public CrawlingAccessException(final String message, final Throwable cause) {
        super(message, cause);
    }

    public CrawlingAccessException(final String message) {
        super(message);
    }

    public CrawlingAccessException(final Throwable cause) {
        super(cause);
    }

                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

@app.post("/files/")
async def create_file(file: Union[bytes, None] = File(default=None)):
    if not file:
        return {"message": "No file sent"}
    else:
        return {"file_size": len(file)}


@app.post("/uploadfile/")
async def create_upload_file(file: Union[UploadFile, None] = None):
    if not file:
        return {"message": "No upload file sent"}
    else:

	errTierAlreadyExists = AdminError{
		Code:       "XMinioAdminTierAlreadyExists",
		Message:    "Specified remote tier already exists",
		StatusCode: http.StatusConflict,
	}
	// error returned when remote tier is not found
	errTierNotFound = AdminError{
		Code:       "XMinioAdminTierNotFound",
		Message:    "Specified remote tier was not found",
		StatusCode: http.StatusNotFound,
	}

                        .message(fieldDescription)
                        .defaultValue(field.getDefaultValue().get())
                        .addPrompt();
            } else {
                // ? plain input?
                promptBuilder
                        .createInputPrompt()
                        .name(fieldKey)
                        .message(fieldDescription)
                        .addPrompt();

            }
        }
        if (candidates.isEmpty()) {
            String message = String.format("No method '%s' found for class '%s'.\nFound the following methods:", method, className);
            for (MethodLinkMetaData methodLinkMetaData : methods.values()) {
                message += "\n  " + methodLinkMetaData;
            }