Struct Cache 

pub struct Cache { /* private fields */ }

A CalDAV source that stores its items in a local folder.

It automatically updates the content of the folder when dropped (see its Drop implementation), but you can also manually call Cache::save_to_folder

Most of its functionality is provided by the CalDavSource async trait it implements. However, since these functions do not need to be actually async, non-async versions of them are also provided for better convenience. See Cache::get_calendar_sync for example

Implementations

impl Cache

pub fn cache_folder() -> PathBuf

Get the path to the cache folder

pub fn from_folder(folder: &Path) -> Result<Self, Box<dyn Error>>

Initialize a cache from the content of a valid backing folder if it exists. Returns an error otherwise

Examples found in repository

examples/shared.rs (line 27)

pub async fn initial_sync(cache_folder: &str) -> CalDavProvider {
    let cache_path = Path::new(cache_folder);

    let client = Client::new(URL, USERNAME, PASSWORD).unwrap();
    let cache = match Cache::from_folder(&cache_path) {
        Ok(cache) => cache,
        Err(err) => {
            log::warn!("Invalid cache file: {}. Using a default cache", err);
            Cache::new(&cache_path)
        }
    };
    let mut provider = CalDavProvider::new(client, cache);


    let cals = provider.local().get_calendars().await.unwrap();
    println!("---- Local items, before sync -----");
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    println!("Starting a sync...");
    println!("Depending on your RUST_LOG value, you may see more or less details about the progress.");
    // Note that we could use sync_with_feedback() to have better and formatted feedback
    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync.");
    }
    provider.local().save_to_folder().unwrap();

    println!("---- Local items, after sync -----");
    let cals = provider.local().get_calendars().await.unwrap();
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    provider
}

pub fn new(folder_path: &Path) -> Self

Initialize a cache with the default contents

Examples found in repository

examples/shared.rs (line 31)

pub async fn initial_sync(cache_folder: &str) -> CalDavProvider {
    let cache_path = Path::new(cache_folder);

    let client = Client::new(URL, USERNAME, PASSWORD).unwrap();
    let cache = match Cache::from_folder(&cache_path) {
        Ok(cache) => cache,
        Err(err) => {
            log::warn!("Invalid cache file: {}. Using a default cache", err);
            Cache::new(&cache_path)
        }
    };
    let mut provider = CalDavProvider::new(client, cache);


    let cals = provider.local().get_calendars().await.unwrap();
    println!("---- Local items, before sync -----");
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    println!("Starting a sync...");
    println!("Depending on your RUST_LOG value, you may see more or less details about the progress.");
    // Note that we could use sync_with_feedback() to have better and formatted feedback
    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync.");
    }
    provider.local().save_to_folder().unwrap();

    println!("---- Local items, after sync -----");
    let cals = provider.local().get_calendars().await.unwrap();
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    provider
}

pub fn save_to_folder(&self) -> Result<(), Error>

Store the current Cache to its backing folder

Note that this is automatically called when self is dropped

Examples found in repository

examples/shared.rs (line 47)

pub async fn initial_sync(cache_folder: &str) -> CalDavProvider {
    let cache_path = Path::new(cache_folder);

    let client = Client::new(URL, USERNAME, PASSWORD).unwrap();
    let cache = match Cache::from_folder(&cache_path) {
        Ok(cache) => cache,
        Err(err) => {
            log::warn!("Invalid cache file: {}. Using a default cache", err);
            Cache::new(&cache_path)
        }
    };
    let mut provider = CalDavProvider::new(client, cache);


    let cals = provider.local().get_calendars().await.unwrap();
    println!("---- Local items, before sync -----");
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    println!("Starting a sync...");
    println!("Depending on your RUST_LOG value, you may see more or less details about the progress.");
    // Note that we could use sync_with_feedback() to have better and formatted feedback
    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync.");
    }
    provider.local().save_to_folder().unwrap();

    println!("---- Local items, after sync -----");
    let cals = provider.local().get_calendars().await.unwrap();
    kitchen_fridge::utils::print_calendar_list(&cals).await;

    provider
}

examples/provider-sync.rs (line 77)

async fn add_items_and_sync_again(provider: &mut CalDavProvider) {
    println!("\nNow, we'll add a calendar and a few tasks and run the sync again.");
    pause();

    // Create a new calendar...
    let new_calendar_url: Url = EXAMPLE_CREATED_CALENDAR_URL.parse().unwrap();
    let new_calendar_name = "A brave new calendar".to_string();
    if let Err(_err) = provider.local_mut()
        .create_calendar(new_calendar_url.clone(), new_calendar_name.clone(), SupportedComponents::TODO, Some("#ff8000".parse().unwrap()))
        .await {
            println!("Unable to add calendar, maybe it exists already. We're not adding it after all.");
    }

    // ...and add a task in it
    let new_name = "This is a new task in a new calendar";
    let new_task = Task::new(String::from(new_name), true, &new_calendar_url);
    provider.local().get_calendar(&new_calendar_url).await.unwrap()
        .lock().unwrap().add_item(Item::Task(new_task)).await.unwrap();


    // Also create a task in a previously existing calendar
    let changed_calendar_url: Url = EXAMPLE_EXISTING_CALENDAR_URL.parse().unwrap();
    let new_task_name = "This is a new task we're adding as an example, with ÜTF-8 characters";
    let new_task = Task::new(String::from(new_task_name), false, &changed_calendar_url);
    let new_url = new_task.url().clone();
    provider.local().get_calendar(&changed_calendar_url).await.unwrap()
        .lock().unwrap().add_item(Item::Task(new_task)).await.unwrap();


    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync. The new task may not have been synced.");
    } else {
        println!("Done syncing the new task '{}' and the new calendar '{}'", new_task_name, new_calendar_name);
    }
    provider.local().save_to_folder().unwrap();

    complete_item_and_sync_again(provider, &changed_calendar_url, &new_url).await;
}

async fn complete_item_and_sync_again(
    provider: &mut CalDavProvider,
    changed_calendar_url: &Url,
    url_to_complete: &Url)
{
    println!("\nNow, we'll mark this last task as completed, and run the sync again.");
    pause();

    let completion_status = CompletionStatus::Completed(Some(Utc::now()));
    provider.local().get_calendar(changed_calendar_url).await.unwrap()
        .lock().unwrap().get_item_by_url_mut(url_to_complete).await.unwrap()
        .unwrap_task_mut()
        .set_completion_status(completion_status);

    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync. The new task may not have been synced.");
    } else {
        println!("Done syncing the completed task");
    }
    provider.local().save_to_folder().unwrap();

    remove_items_and_sync_again(provider, changed_calendar_url, url_to_complete).await;
}

async fn remove_items_and_sync_again(
    provider: &mut CalDavProvider,
    changed_calendar_url: &Url,
    id_to_remove: &Url)
{
    println!("\nNow, we'll delete this last task, and run the sync again.");
    pause();

    // Remove the task we had created
    provider.local().get_calendar(changed_calendar_url).await.unwrap()
        .lock().unwrap()
        .mark_for_deletion(id_to_remove).await.unwrap();

    if provider.sync().await == false {
        log::warn!("Sync did not complete, see the previous log lines for more info. You can safely start a new sync. The new task may not have been synced.");
    } else {
        println!("Done syncing the deleted task");
    }
    provider.local().save_to_folder().unwrap();

    println!("Done. You can start this example again to see the cache being restored from its current saved state")
}

impl Cache

pub fn get_calendars_sync( &self, ) -> Result<HashMap<Url, Arc<Mutex<CachedCalendar>>>, Box<dyn Error>>

The non-async version of crate::traits::CalDavSource::get_calendars

Examples found in repository

examples/toggle-completions.rs (line 40)

async fn toggle_all_tasks_and_sync_again(provider: &mut CalDavProvider) -> Result<(), Box<dyn Error>> {
    let mut n_toggled = 0;

    for (_url, cal) in provider.local().get_calendars_sync()?.iter() {
        for (_url, item) in cal.lock().unwrap().get_items_mut_sync()?.iter_mut() {
            match item {
                Item::Task(task) => {
                    match task.completed() {
                        false => task.set_completion_status(CompletionStatus::Completed(Some(Utc::now()))),
                        true => task.set_completion_status(CompletionStatus::Uncompleted),
                    };
                    n_toggled += 1;
                }
                Item::Event(_) => {
                    // Not doing anything with calendar events
                },
            }
        }
    }

    println!("{} items toggled.", n_toggled);
    println!("Syncing...");

    provider.sync().await;

    println!("Syncing complete.");

    Ok(())
}

pub fn get_calendar_sync(&self, url: &Url) -> Option<Arc<Mutex<CachedCalendar>>>

The non-async version of crate::traits::CalDavSource::get_calendar

Trait Implementations

impl CalDavSource<CachedCalendar> for Cache

fn get_calendars<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<Url, Arc<Mutex<CachedCalendar>>>, Box<dyn Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current calendars that this source contains This function may trigger an update (that can be a long process, or that can even fail, e.g. in case of a remote server)

fn get_calendar<'life0, 'life1, 'async_trait>( &'life0 self, url: &'life1 Url, ) -> Pin<Box<dyn Future<Output = Option<Arc<Mutex<CachedCalendar>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the calendar matching the URL

fn create_calendar<'life0, 'async_trait>( &'life0 mut self, url: Url, name: String, supported_components: SupportedComponents, color: Option<Color>, ) -> Pin<Box<dyn Future<Output = Result<Arc<Mutex<CachedCalendar>>, Box<dyn Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a calendar if it did not exist, and return it

impl Debug for Cache

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

Formats the value using the given formatter.

impl Drop for Cache

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.