Struct PrecreateOptions 

pub struct PrecreateOptions {
    pub path: String,
    pub size: u64,
    pub isdir: i32,
    pub block_list: Vec<String>,
    pub rtype: i32,
    pub uploadid: Option<String>,
    pub content_md5: Option<String>,
    pub slice_md5: Option<String>,
    pub local_ctime: Option<u64>,
    pub local_mtime: Option<u64>,
}

Options for precreate upload

Fields

path: String

Remote file path on Baidu NetDisk

size: u64

File size in bytes

isdir: i32

Is directory (0 for file, 1 for directory)

block_list: Vec<String>

List of block MD5s (each block is typically 4MB)

rtype: i32

Conflict resolution type (1=overwrite, 2=rename, 3=new copy)

uploadid: Option<String>

Optional uploadid for resuming interrupted uploads

content_md5: Option<String>

Optional content MD5 for entire file

slice_md5: Option<String>

Optional slice MD5

local_ctime: Option<u64>

Optional local creation time (timestamp)

local_mtime: Option<u64>

Optional local modification time (timestamp)

Implementations

impl PrecreateOptions

pub fn new(path: &str, size: u64, block_list: Vec<String>) -> Self

Create new PrecreateOptions with basic required fields

Examples found in repository

examples/upload_precreate.rs (line 77)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

pub fn isdir(self, isdir: bool) -> Self

Set whether this is a directory

pub fn rtype(self, rtype: i32) -> Self

Set conflict resolution type (1=overwrite, 2=rename, 3=new copy)

Examples found in repository

examples/upload_precreate.rs (line 79)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

pub fn uploadid(self, uploadid: &str) -> Self

Set uploadid for resuming an interrupted upload

pub fn content_md5(self, md5: &str) -> Self

Set content MD5 for the entire file

Examples found in repository

examples/upload_precreate.rs (line 78)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

pub fn slice_md5(self, md5: &str) -> Self

Set slice MD5

pub fn local_ctime(self, ctime: u64) -> Self

Set local creation time (timestamp)

pub fn local_mtime(self, mtime: u64) -> Self

Set local modification time (timestamp)

Trait Implementations

impl Clone for PrecreateOptions

fn clone(&self) -> PrecreateOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrecreateOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PrecreateOptions

fn default() -> PrecreateOptions

Returns the “default value” for a type.