Interface for file upload and download operations via URLs. More...

#include <IFileTransfer.h>

Inherits istd::IPolymorphic.

Inherited by imthttp::CHttpFileTransfer [virtual].

Public Member Functions
virtual bool	UploadFile (const QString &filePath, const QUrl &url) const =0
	Upload a local file to a remote URL.

virtual bool	DownloadFile (const QString &filePath, const QUrl &url) const =0
	Download a remote file to a local path.

Detailed Description

Interface for file upload and download operations via URLs.

IFileTransfer provides a simple contract for transferring files to and from remote servers using URL-based addressing. This interface abstracts the underlying transfer protocol (HTTP, FTP, etc.) and provides a uniform API for file operations.

Key Features

Bidirectional Transfer:

UploadFile(): Send local file to remote server
DownloadFile(): Retrieve remote file to local filesystem
URL-based addressing for flexibility

Protocol Agnostic:

Supports HTTP/HTTPS (typical implementation)
Potentially FTP, SFTP, or custom protocols
Protocol determined by URL scheme (http://, ftp://, etc.)

Synchronous Operations:

Blocking calls that complete before returning
Return value indicates success/failure
Use in separate thread if non-blocking behavior required

Implementation

Primary Implementation:

imthttp::CHttpFileTransfer: HTTP/HTTPS-based file transfer
Supports authentication via IServerConnectionInterface
Handles multipart/form-data encoding for uploads
Manages progress tracking and error handling

Usage Examples

File Upload

IFileTransfer* transfer = ...;  // e.g., imthttp::CHttpFileTransfer
 
// Upload local file to server
QString localFile = "/path/to/document.pdf";
QUrl uploadUrl("https://example.com/api/upload");
 
if (transfer->UploadFile(localFile, uploadUrl)) {
    qDebug() << "File uploaded successfully";
} else {
    qCritical() << "Upload failed";
    // Check logs for detailed error
}

File Download

IFileTransfer* transfer = ...;
 
// Download remote file to local path
QString localPath = "/tmp/downloaded-report.pdf";
QUrl downloadUrl("https://example.com/api/files/report-2024.pdf");
 
if (transfer->DownloadFile(localPath, downloadUrl)) {
    qDebug() << "File downloaded to:" << localPath;
    QFile::exists(localPath);  // Verify file exists
} else {
    qCritical() << "Download failed";
}

Document Management System

class DocumentManager : public QObject {
public:
    DocumentManager(IFileTransfer* transfer, const QUrl& baseUrl)
        : m_transfer(transfer), m_baseUrl(baseUrl) {}
    
    bool UploadDocument(const QString& localPath, const QString& documentId) {
        QUrl uploadUrl = m_baseUrl;
        uploadUrl.setPath(QString("/documents/%1").arg(documentId));
        
        qInfo() << "Uploading document" << documentId << "from" << localPath;
        
        if (m_transfer->UploadFile(localPath, uploadUrl)) {
            qInfo() << "Document uploaded successfully";
            emit documentUploaded(documentId);
            return true;
        } else {
            qCritical() << "Failed to upload document";
            emit uploadFailed(documentId);
            return false;
        }
    }
    
    bool DownloadDocument(const QString& documentId, const QString& localPath) {
        QUrl downloadUrl = m_baseUrl;
        downloadUrl.setPath(QString("/documents/%1").arg(documentId));
        
        qInfo() << "Downloading document" << documentId << "to" << localPath;
        
        if (m_transfer->DownloadFile(localPath, downloadUrl)) {
            qInfo() << "Document downloaded successfully";
            emit documentDownloaded(documentId, localPath);
            return true;
        } else {
            qCritical() << "Failed to download document";
            emit downloadFailed(documentId);
            return false;
        }
    }
    
signals:
    void documentUploaded(const QString& documentId);
    void documentDownloaded(const QString& documentId, const QString& path);
    void uploadFailed(const QString& documentId);
    void downloadFailed(const QString& documentId);
    
private:
    IFileTransfer* m_transfer;
    QUrl m_baseUrl;
};

Best Practices

Error Handling: Always check return value and log failures
- Network errors, permission issues, disk full, etc.
- Provide user feedback for failed operations
File Validation: Verify file exists before upload
if (!QFile::exists(localPath)) {

qCritical() << "File not found:" << localPath;

return false;

}

transfer->UploadFile(localPath, url);
URL Construction: Use QUrl for proper URL encoding
QUrl url("https://example.com/api/upload");

url.setQuery("token=abc123"); // Proper encoding
Path Validation: Ensure local paths are writable for downloads
QFileInfo info(localPath);

if (!info.dir().exists()) {

info.dir().mkpath("."); // Create directory

}
Large Files: Consider using separate thread for blocking operations
QtConcurrent::run([transfer, localPath, url]() {

return transfer->UploadFile(localPath, url);

});
Authentication: Ensure URL includes auth tokens or use authenticated client
- Add tokens to URL query string
- Configure IServerConnectionInterface with credentials
- Use HTTPS for secure token transmission

Limitations

Synchronous (blocking) operations - may hang UI if called on main thread
No built-in progress reporting - implement separately if needed
No resume capability for interrupted transfers
No multi-part upload support in interface (implementation-specific)

Integration Points

Implementations:

imthttp::CHttpFileTransfer: HTTP/HTTPS file transfer
- Uses IServerConnectionInterface for server configuration
- Supports authentication headers
- Handles chunked transfer encoding

Related Components:

IServerConnectionInterface: Provides server URL configuration
imtservergql: GraphQL endpoints for file metadata
imtrest: File upload/download servlets

See also: imthttp::CHttpFileTransfer, IServerConnectionInterface

Definition at line 202 of file IFileTransfer.h.

Member Function Documentation

◆ DownloadFile()

virtual bool imtcom::IFileTransfer::DownloadFile	(	const QString &	filePath,
		const QUrl &	url
	)		const

pure virtual

Download a remote file to a local path.

Downloads the file from the specified URL and saves it to the local filesystem. The operation is synchronous and blocks until completion or failure.

Parameters

filePath	Absolute path where the downloaded file should be saved. Parent directory must exist and be writable.
url	Remote URL of the file to download. Typically an HTTP(S) endpoint.

Returns: true if download completed successfully; false on any error.

Example:: QString savePath = "/tmp/report.pdf";

QUrl fileUrl("https://example.com/reports/2024-annual.pdf");

if (transfer->DownloadFile(savePath, fileUrl)) {

qDebug() << "Downloaded to:" << savePath;

// File now available at savePath

} else {

qCritical() << "Download failed";

}

Note: This is a blocking operation. For large files or UI applications, consider executing in a separate thread.

Warning: If the local file already exists, it will be overwritten without warning.

See also: UploadFile()

◆ UploadFile()

virtual bool imtcom::IFileTransfer::UploadFile	(	const QString &	filePath,
		const QUrl &	url
	)		const