vstorage 0.8.1

Common API for various icalendar/vcard storages.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright 2023-2026 Hugo Osvaldo Barrera
//
// SPDX-License-Identifier: EUPL-1.2

//! Property operation planning.

use std::{
    collections::{HashMap, HashSet},
    sync::Arc,
};

use crate::{
    ErrorKind,
    property::Property,
    sync::{
        declare::StoragePair,
        mapping::ResolvedMapping,
        mode::Mode,
        operation::PropertyOp,
        ordering::DeletionBarrier,
        plan::PlanError,
        status::{MappingUid, StatusDatabase},
    },
};

/// Load properties and create property operations using mode-based approach.
pub(crate) async fn load_and_create_property_operations(
    mapping: &Arc<ResolvedMapping>,
    mapping_uid: Option<MappingUid>,
    pair: &StoragePair,
    status: Option<&StatusDatabase>,
    deletion_completion: Option<&DeletionBarrier>,
    mode: &dyn Mode,
) -> Result<Vec<PropertyOp>, PlanError> {
    let (props_a, props_b) = match tokio::try_join!(
        pair.storage_a().list_properties(mapping.a().href()),
        pair.storage_b().list_properties(mapping.b().href()),
    ) {
        Ok((a, b)) => (a, b),
        Err(error) => {
            // If storage doesn't support properties or doesn't exist, return empty
            return if let ErrorKind::DoesNotExist | ErrorKind::Unsupported = error.kind {
                Ok(Vec::new())
            } else {
                Err(error.into())
            };
        }
    };

    let props_status = match (status, mapping_uid) {
        (Some(s), Some(u)) => s.list_properties_for_collection(u)?,
        _ => Vec::with_capacity(0),
    };

    // FIXME: properties require mapping_uid. Should require MappingUidSource.
    let Some(mapping_uid) = mapping_uid else {
        return Ok(Vec::new());
    };

    // Convert to owned collections for easier manipulation
    // FIXME: a lot of pointless work.
    let mut values_a: HashMap<Property, String> =
        props_a.into_iter().map(|p| (p.property, p.value)).collect();
    let mut values_b: HashMap<Property, String> =
        props_b.into_iter().map(|p| (p.property, p.value)).collect();
    let mut previous_values: HashMap<String, String> = props_status
        .into_iter()
        .map(|p| (p.property, p.value))
        .collect();

    // Collect all unique properties
    let all_props: HashSet<Property> = values_a.keys().chain(values_b.keys()).copied().collect();

    let operations: Vec<PropertyOp> = all_props
        .into_iter()
        .filter_map(|property: Property| {
            let from_a = values_a.remove(&property);
            let from_b = values_b.remove(&property);
            let from_status = previous_values.remove(property.name());
            mode.decide_property_action(
                property,
                from_a,
                from_b,
                from_status,
                mapping,
                mapping_uid,
                deletion_completion,
            )
        })
        .collect();

    Ok(operations)
}