try (Stream<Path> stream = Files.list(logDirPath)) {
                stream.filter(entry -> isLogFilename(entry.getFileName().toString())).forEach(filePath -> {
                    final ZipEntry entry = new ZipEntry(id + "/" + filePath.getFileName().toString());
                    try {
                        zos.putNextEntry(entry);
                        final long len = Files.copy(filePath, zos);

                                }
                            }
                        });
            } catch (final Exception e) {
                logger.warn("Failed to process request file: {}", form.requestFile.getFileName(), e);
                throwValidationError(messages -> messages.addErrorsInvalidHeaderForRequestFile(GLOBAL, e.getMessage()),
                        () -> asListHtml(this::saveToken));
            }
        }

        assertEquals("test", artifact.getName());
        assertEquals("1.0.0", artifact.getVersion());
        assertEquals("http://test.com/test.jar", artifact.getUrl());
        assertEquals("test-1.0.0.jar", artifact.getFileName());
        assertEquals(ArtifactType.UNKNOWN, artifact.getType());
    }

    @Test
    public void test_Artifact_constructorWithoutUrl() {
        Artifact artifact = new Artifact("test", "1.0.0");

        validateApi(form, messages -> {});
        if (form.file == null) {
            throwValidationErrorApi(messages -> messages.addErrorsStorageNoUploadFile(GLOBAL));
        }
        final String fileName = form.file.getFileName();
        try {
            uploadObject(getObjectName(form.path, fileName), form.file);
            saveInfo(messages -> messages.addSuccessUploadFileToStorage(GLOBAL, fileName));

        try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {
            pathStream.filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".adoc"))
                .map(p -> p.getFileName().toString())
                .forEach(foundAdocFiles::add);
        }

        for (AdocFileEntry entry : entries) {
            String filename = entry.filename;

        assertEquals(0xA5A5A5A5, resp.getAttributes()); // SmbBasicFileInfo mapping
        assertArrayEquals(fileId, resp.getFileId());
        assertEquals("file.txt", resp.getFileName());

        // No create contexts section present -> null
        assertNull(resp.getCreateContexts());
    }

    @Test
    void decode_withCreateContext_unrecognized_yieldsEmptyArray() throws Exception {

                suggestHelper.storeAllBadWords(false);
            } catch (final Exception e) {
                throw new FessSystemException("Failed to import bad word data: fileName=" + form.badWordFile.getFileName(), e);
            }
        });
        saveInfo(messages -> messages.addSuccessUploadBadWord(GLOBAL));
        return redirect(getClass());
    }

     * @param path the path to the artifact file
     */
    default void attachArtifact(@Nonnull Session session, @Nonnull Project project, @Nonnull Path path) {
        String name = path.getFileName().toString();
        int dot = name.lastIndexOf('.');
        String ext = dot >= 1 ? name.substring(dot + 1) : "";
        ProducedArtifact artifact = session.createProducedArtifact(

    public HtmlResponse upload(final UploadForm form) {
        validate(form, messages -> {}, () -> asListHtml(form));
        verifyToken(this::asListHtml);
        final String uploadedFileName = form.designFile.getFileName();
        String fileName = form.designFileName;
        if (StringUtil.isBlank(fileName)) {
            fileName = uploadedFileName;
            try {
                int pos = fileName.indexOf('/');

    @Secured({ ROLE })
    public HtmlResponse upload(final UploadForm form) {
        validate(form, messages -> {}, this::asListHtml);
        verifyToken(this::asListHtml);
        final String fileName = form.bulkFile.getFileName();

        if (logger.isDebugEnabled()) {
            logger.debug("Backup file upload initiated: fileName={}", fileName);
        }