public Response exportContentToZip(@Context SecurityContext securityContext, @Context HttpServletRequest request,
            @Multipart(value = "batchSize", required = false) String batchSizeParam,
            @Multipart(value = "throttle", required = false) String throttleParam,
            @Multipart(value = "publishOnImport", required = false) String publishOnImportParam,
            @Multipart(value = "dataUrlSizeThreshold", required = false) String dataUrlSizeThresholdParam,
            @Multipart(value = "docbasePropNames", required = false) String docbasePropNamesParam,
            @Multipart(value = "documentTags", required = false) String documentTagsParam,
            @Multipart(value = "binaryTags", required = false) String binaryTagsParam,
            @Multipart(value = "paramsJson", required = false) String paramsJsonParam,
            @Multipart(value = "params", required = false) Attachment paramsAttachment) {

result.incrementFailedBinaryCount();
                    }
                    if (processStatus != null) {
                        // the remaining 5% for cleaning paths to convert those to uuids.
                        processStatus.setProgress(0.95 * ((double) batchCount) / ((double) jsonFiles.length));
                    }
                }
                ++batchCount;
                if (batchCount % params.getBatchSize() == 0) {
                    importTask.getDocumentManager().getSession().save();
                    importTask.getDocumentManager().getSession().refresh(false);
                    if (params.getThrottle() > 0) {
                        Thread.sleep(params.getThrottle());
                    }
                }
            }
        }

        importTask.getDocumentManager().getSession().save();
        importTask.getDocumentManager().getSession().refresh(false);

        return batchCount;
    }

    private int importDocuments(Logger procLogger, ProcessStatus processStatus, FileObject[] jsonFiles,

applyTagContentProperties(contentNode, params.getBinaryTags());

                String relPath = StringUtils.removeStart(ContentPathUtils.removeIndexNotationInNodePath(variantPath),
                        "/");
                FileObject file = baseFolder.resolveFile(relPath + ".json");
                record.setAttribute("file", file.getName().getPath());
                exportTask.writeContentNodeToJsonFile(contentNode, file);

                procLogger.debug("Exported document from {} to {}.", handlePath, file.getName().getPath());
                record.setSucceeded(true);
            } catch (Exception e) {
                procLogger.error("Failed to process record: {}", record, e);
                if (record != null) {
                    record.setErrorMessage(e.toString());
                }
            } finally {
                if (record != null) {
                    exportTask.endRecord();
                    result.incrementTotalBinaryCount();

public DefaultBinaryImportTask(final DocumentManager documentManager) {
        super(documentManager);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public ContentNodeBindingItemFilter<ContentItem> getContentNodeBindingItemFilter() {
        if (contentNodeBindingItemFilter == null) {
            DefaultContentNodeJcrBindingItemFilter filter = new DefaultContentNodeJcrBindingItemFilter();
            filter.addPropertyPathExclude(Constants.META_PROP_NODE_LOCALIZED_NAME);
            filter.addPropertyPathExclude(Constants.META_PROP_NODE_PATH);
            filter.addPropertyPathExclude("hippostdpubwf:*");
            filter.addPropertyPathExclude("hippo:availability");
            filter.addPropertyPathExclude("hippo:paths");
            filter.addPropertyPathExclude("hippo:related");
            filter.addPropertyPathExclude("hippostd:holder");
            filter.addPropertyPathExclude("hippostd:state");
            filter.addPropertyPathExclude("hippostd:stateSummary");
            contentNodeBindingItemFilter = filter;
        }

        return contentNodeBindingItemFilter;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String createOrUpdateBinaryFolder(String folderLocation, String primaryTypeName, String[] folderTypes,

if (paramsAttachment != null) {
                final String json = attachmentToString(paramsAttachment, "UTF-8");
                if (StringUtils.isNotBlank(json)) {
                    params = getObjectMapper().readValue(json, ExecutionParams.class);
                }
            } else {
                if (StringUtils.isNotBlank(paramsJsonParam)) {
                    params = getObjectMapper().readValue(paramsJsonParam, ExecutionParams.class);
                }
            }
            overrideExecutionParamsByParameters(params, batchSizeParam, throttleParam, publishOnImportParam,
                    dataUrlSizeThresholdParam, docbasePropNamesParam, documentTagsParam, binaryTagsParam);

            if (processStatus != null) {
                processStatus.setExecutionParams(params);
            }

ExecutionParams params, FileObject baseFolder, DefaultBinaryImportTask importTask, Result result,
            int batchCount) throws Exception {
        final String baseFolderUrlPrefix = baseFolder.getURL().toString();
        final AntPathMatcher pathMatcher = new AntPathMatcher();

        for (FileObject file : jsonFiles) {
            if (isStopRequested(baseFolder)) {
                procLogger.info("Stop requested by file at {}/{}", baseFolder.getName().getPath(),
                        STOP_REQUEST_FILE_REL_PATH);
                break;
            }

            ContentNode contentNode = importTask.readContentNodeFromJsonFile(file);

            String primaryTypeName = contentNode.getPrimaryType();
            String path = contentNode.getProperty("jcr:path").getValue();

            if (!isBinaryPathIncluded(pathMatcher, params, path)) {