}
    }

    private static int process(final Options options) {
        final Crawler crawler = ComponentUtil.getComponent(Crawler.class);

        if (StringUtil.isBlank(options.sessionId)) {
            // use a default session id
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
            options.sessionId = sdf.format(new Date());
        } else {

                writeRaw(indent);
            }
        }

        writeRaw("<!--");
        if (!StringUtils.isBlank(comment.substring(0, 1))) {
            writeRaw(" ");
        }
        writeSafeCharacters(comment);
        if (!StringUtils.isBlank(comment.substring(comment.length() - 1))) {
            writeRaw(" ");
        }
        writeRaw("-->");
        return this;
    }

        return userBhv.selectEntity(cb -> {
            cb.query().setName_Equal(username);
        });
    }

    public void store(final User user) {
        if (StringUtil.isBlank(user.getSurname())) {
            user.setSurname(user.getName());
        }

        ComponentUtil.getAuthenticationManager().insert(user);

        userBhv.insertOrUpdate(user, op -> {

        }

        List<String> compilerArgs = new JavaCompilerArgumentsBuilder(spec).includeLauncherOptions(true).includeSourceFiles(true).build();
        String joinedArgs = compilerArgs.stream().map(it -> StringUtils.isBlank(it) ? ('"' + it + '"') : it).collect(Collectors.joining(" "));
        LOGGER.debug("Compiler arguments: {}", joinedArgs);
    }

    private WorkResult delegateAndHandleErrors(JavaCompileSpec spec) {
        try {

            throw new MimeTypeException("Could not detect a content type.", e);
        }
    }

    protected String normalizeFilename(final String filename) {
        if (StringUtil.isBlank(filename)) {
            return filename;
        }
        final StringBuilder buf = new StringBuilder(filename.length() + 10);
        for (int i = 0; i < filename.length(); i++) {

        // Don't allow paths that are:
        // - empty or blank
        // - the root path
        // - have empty or blank segments (eg `::a`, `a::b`, `a:  :b`, etc)

        if (name.isEmpty() || StringUtils.isBlank(name)) {
            throw problemsService.getInternalReporter().throwing(spec -> {
                spec.id("empty-path", "Empty path", GradleCoreProblemGroup.taskSelection());

            return "Unknown error";
        }

        final Supplier<String> stacktraceString = () -> {
            final StringBuilder sb = new StringBuilder();
            if (StringUtil.isBlank(cause.getMessage())) {
                sb.append(cause.getClass().getName());
            } else {
                sb.append(cause.getMessage());
            }

            } else {
                this.queryString = queryString;
            }
        } else {
            this.queryString = queryString;
        }
        if (StringUtil.isBlank(this.queryString)) {
            this.queryString = "*";
        }
        if (isQuery) {
            LaRequestUtil.getOptionalRequest().ifPresent(request -> {
                highlightedQuerySet = new HashSet<>();

    private Optional<URI> configureEndpoint(String property) {
        URI uri = null;
        if (StringUtils.isNotBlank(property)) {
            try {
                uri = new URI(property);
                if (StringUtils.isBlank(uri.getScheme()) || !SUPPORTED_SCHEMES.contains(uri.getScheme().toUpperCase())) {

            final String secretKey = System.getenv().get("STORAGE_SECRET_KEY");
            final String region = System.getenv().get("STORAGE_SECRET_KEY");
            try {
                if (StringUtil.isBlank(endpoint)) {
                    throw new IOException("endpoint is blank.");
                }
                final Builder builder = MinioClient.builder().endpoint(endpoint);