Rust driver tutorial

fn create_database(driver: &Connection, db_name: String) -> Result<bool, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver.to_owned());
    print!("Creating a new database...");
    let result = databases.create(&db_name);
    match result {
        Ok(_) => {
            println!("OK");
        }
        Err(_) => return Err(Box::new(TypeDBError::Other("Failed to create a DB.".to_string()))),
    };
    {
        let schema_session = Session::new(databases.get(&db_name)?, SessionType::Schema)?;
        db_schema_setup(&schema_session, "iam-schema.tql".to_string())?;
    }
    {
        let data_session = Session::new(databases.get(&db_name)?, SessionType::Data)?;
        db_dataset_setup(&data_session, "iam-data-single-query.tql".to_string())?;
    }
    return Ok(true);
}

fn replace_database(driver: &Connection, db_name: String) -> Result<bool, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver.to_owned());
    print!("Deleting an existing database...");
    let deletion_result = databases.get(&db_name)?.delete();
    match deletion_result {
        Ok(_) => println!("OK"),
        Err(_) => return Err(Box::new(TypeDBError::Other("Failed to delete a database.".to_string()))),
    };
    let creation_result = create_database(&driver, db_name);
    match creation_result {
        Ok(_) => return Ok(true),
        Err(_) => return Err(Box::new(TypeDBError::Other("Failed to create a new database.".to_string()))),
    };
}

fn db_schema_setup(schema_session: &Session, schema_file: String) -> Result<(), TypeDBError> {
    let tx = schema_session.transaction(TransactionType::Write)?;
    let data = fs::read_to_string(schema_file)?; // "iam-schema.tql"
    print!("Defining schema...");
    let response = tx.query().define(&data).resolve();
    tx.commit().resolve()?;
    println!("OK");
    return response;
}

fn db_dataset_setup(data_session: &Session, data_file: String) -> Result<(), Box<dyn Error>> {
    let tx = data_session.transaction(TransactionType::Write)?;
    let data = fs::read_to_string(data_file)?; // "iam-data-single-query.tql"
    print!("Loading data...");
    let response = tx.query().insert(&data)?;
    let result = response.collect::<Vec<_>>();
    tx.commit().resolve()?;
    println!("OK");
    Ok({
        drop(result);
    })
}

fn db_check(data_session: &Session) -> Result<bool, Box<dyn Error>> {
    let tx = data_session.transaction(TransactionType::Write)?;
    let test_query = "match $u isa user; get $u; count;";
    print!("Testing the database...");
    let response = tx.query().get_aggregate(test_query).resolve();
    let result = match response?.ok_or("Error: unexpected test query response.")? {
        Value::Long(value) => value,
        _ => unreachable!(),
    };
    if result == 3 {
        println!("OK");
        Ok(true)
    } else {
        Err(Box::new(TypeDBError::Other("Test failed. Terminating...".to_string())))
    }
}

fn fetch_all_users(driver: Connection, db_name: String) -> Result<Vec<JSON>, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver);
    let session = Session::new(databases.get(db_name)?, SessionType::Data)?;
    let tx = session.transaction(TransactionType::Read)?;
    let iterator = tx.query().fetch("match $u isa user; fetch $u: full-name, email;")?;
    let mut count = 0;
    let mut result = vec![];
    for item in iterator {
        count += 1;
        let json = item?;
        println!("User #{}: {}", count.to_string(), json.to_string());
        result.push(json);
    }
    if result.len() > 0 {
        Ok(result)
    } else {
        Err(Box::new(TypeDBError::Other("Error: No users found in a database.".to_string())))
    }
}

fn insert_new_user(
    driver: Connection,
    db_name: String,
    new_name: &str,
    new_email: &str,
) -> Result<Vec<ConceptMap>, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver);
    let session = Session::new(databases.get(db_name)?, SessionType::Data)?;
    let tx = session.transaction(TransactionType::Write)?;
    let iterator = tx.query().insert(&format!(
        "insert $p isa person, has full-name $fn, has email $e; $fn == '{}'; $e == '{}';",
        new_name, new_email
    ))?;
    let mut result = vec![];
    for item in iterator {
        let concept_map = item?;
        let name = unwrap_string(concept_map.get("fn").unwrap().clone());
        let email = unwrap_string(concept_map.get("e").unwrap().clone());
        println!("Added new user. Name: {}, E-mail: {}", name, email);
        result.push(concept_map);
    }
    if result.len() > 0 {
        let _ = tx.commit().resolve();
        Ok(result)
    } else {
        Err(Box::new(TypeDBError::Other("Error: No users found in a database.".to_string())))
    }
}

fn get_files_by_user(
    driver: Connection,
    db_name: String,
    name: &str,
    inference: bool,
) -> Result<Vec<(usize, ConceptMap)>, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver);
    let session = Session::new(databases.get(db_name)?, SessionType::Data)?;
    let tx = session.transaction_with_options(TransactionType::Read, Options::new().infer(inference))?;
    let users = tx
        .query()
        .get(&format!("match $u isa user, has full-name '{}'; get;", name))?
        .map(|x| x.unwrap())
        .collect::<Vec<_>>();
    let response;
    if users.len() > 1 {
        return Err(Box::new(TypeDBError::Other("Found more than one user with that name.".to_string())));
    } else if users.len() == 1 {
        response = tx
            .query()
            .get(&format!(
                "match
                    $fn == '{}';
                    $u isa user, has full-name $fn;
                    $p($u, $pa) isa permission;
                    $o isa object, has path $fp;
                    $pa($o, $va) isa access;
                    $va isa action, has name 'view_file';
                    get $fp; sort $fp asc;
                    ",
                name
            ))?
            .map(|x| x.unwrap())
            .enumerate()
            .collect::<Vec<_>>();
        for (count, file) in &response {
            println!("File #{}: {}", count + 1, unwrap_string(file.get("fp").unwrap().clone()));
        }
        if response.len() == 0 {
            println!("No files found. Try enabling inference.");
        }
        return Ok(response);
    } else {
        return Err(Box::new(TypeDBError::Other("No users found with that name.".to_string())));
    }
}

fn update_filepath(
    driver: Connection,
    db_name: String,
    old_path: &str,
    new_path: &str,
) -> Result<Vec<ConceptMap>, Box<dyn Error>> {
    let databases = DatabaseManager::new(driver);
    let session = Session::new(databases.get(db_name)?, SessionType::Data)?;
    let tx = session.transaction(TransactionType::Write)?;
    let response = tx
        .query()
        .update(&format!(
            "match
                $f isa file, has path $old_path;
                $old_path = '{old}';
                delete
                $f has $old_path;
                insert
                $f has path $new_path;
                $new_path = '{new}';",
            old = old_path,
            new = new_path
        ))?
        .map(|x| x.unwrap())
        .collect::<Vec<_>>();
    if response.len() > 0 {
        let _ = tx.commit().resolve();
        println!("Total number of paths updated: {}", response.len());
        return Ok(response);
    } else if response.len() == 0 {
        println!("No matched paths: nothing to update");
        return Ok(response);
    } else {
        return Err(Box::new(TypeDBError::Other("Impossible query response.".to_string())));
    }
}

fn delete_file(driver: Connection, db_name: String, path: &str) -> Result<(), Box<dyn Error>> {
    let databases = DatabaseManager::new(driver);
    let session = Session::new(databases.get(db_name)?, SessionType::Data)?;
    let tx = session.transaction(TransactionType::Write)?;
    let files = tx
        .query()
        .get(&format!(
            "match
                $f isa file, has path '{}';
                get;",
            path
        ))?
        .map(|x| x.unwrap())
        .collect::<Vec<_>>();
    if files.len() == 1 {
        let response = tx
            .query()
            .delete(&format!(
                "match
                    $f isa file, has path '{path}';
                    delete
                    $f isa file;
                    "
            ))
            .resolve();
        match response {
            Ok(_) => {
                println!("File has been deleted.");
                Ok(())
            }
            Err(_) => return Err(Box::new(TypeDBError::Other("Error: Failed to delete.".to_string()))),
        }
    } else {
        return Err(Box::new(TypeDBError::Other(
            format!("Wrong number of files to delete: {}", files.len()).to_string(),
        )));
    }
}