qm-entity 0.0.76

Entity management
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::sync::Arc;

use async_graphql::Description;
use async_graphql::InputValueError;
use async_graphql::InputValueResult;
use async_graphql::OneofObject;
use async_graphql::Scalar;
use async_graphql::ScalarType;
use async_graphql::Value;

use crate::ids::CustomerId;
use crate::ids::CustomerResourceId;
use crate::ids::InfraContext;
use crate::ids::InstitutionId;
use crate::ids::InstitutionResourceId;
use crate::ids::OrganizationId;
use crate::ids::OrganizationResourceId;

/// GraphQL scalar type for InfraContext.
#[cfg_attr(
    feature = "serde-str",
    derive(serde::Deserialize, serde::Serialize),
    serde(transparent)
)]
pub struct InfraContextId(pub InfraContext);

impl Description for InfraContextId {
    fn description() -> &'static str {
        "InfraContextId"
    }
}

#[Scalar(use_type_description)]
impl ScalarType for InfraContextId {
    fn parse(value: Value) -> InputValueResult<Self> {
        if let Value::String(value) = &value {
            // Parse the integer value
            Ok(InfraContextId(
                InfraContext::parse(value)
                    .map_err(|err| InputValueError::custom(err.to_string()))?,
            ))
        } else {
            // If the type does not match
            Err(InputValueError::expected_type(value))
        }
    }

    fn to_value(&self) -> Value {
        Value::String(self.0.to_string())
    }
}

/// Macro to implement GraphQL scalar type for ID types.
#[macro_export]
macro_rules! impl_id_scalar {
    ($t:ty) => {
        #[Scalar(use_type_description)]
        impl ScalarType for $t {
            fn parse(value: Value) -> InputValueResult<Self> {
                if let Value::String(value) = &value {
                    // Parse the integer value
                    Ok(<$t>::parse(value)
                        .map_err(|err| InputValueError::custom(err.to_string()))?)
                } else {
                    // If the type does not match
                    Err(InputValueError::expected_type(value))
                }
            }

            fn to_value(&self) -> Value {
                Value::String(self.to_string())
            }
        }
    };
}

impl_id_scalar!(CustomerId);
impl_id_scalar!(CustomerResourceId);
impl_id_scalar!(OrganizationId);
impl_id_scalar!(OrganizationResourceId);
impl_id_scalar!(InstitutionId);
impl_id_scalar!(InstitutionResourceId);

/// GraphQL input type for customer or organization ID.
#[derive(OneofObject)]
pub enum CustomerOrOrganization {
    /// Customer ID.
    Customer(CustomerId),
    /// Organization ID.
    Organization(OrganizationId),
}

/// GraphQL input type for organization or institution ID.
#[derive(OneofObject, serde::Serialize, serde::Deserialize)]
#[serde(tag = "t", content = "c")]
pub enum OrganizationOrInstitution {
    /// Organization ID.
    Organization(OrganizationId),
    /// Institution ID.
    Institution(InstitutionId),
}

/// Collection of customer IDs.
pub type CustomerIds = Arc<[CustomerId]>;
/// Collection of customer resource IDs.
pub type CustomerResourceIds = Arc<[CustomerResourceId]>;
/// Collection of organization IDs.
pub type OrganizationIds = Arc<[OrganizationId]>;
/// Collection of organization resource IDs.
pub type OrganizationResourceIds = Arc<[OrganizationResourceId]>;
/// Collection of institution IDs.
pub type InstitutionIds = Arc<[InstitutionId]>;
/// Collection of institution resource IDs.
pub type InstitutionResourceIds = Arc<[InstitutionResourceId]>;

#[cfg(test)]
mod tests {
    #[cfg(feature = "serde-str")]
    #[test]
    fn test_infra_context_id_serde() {
        use super::{InfraContext, InfraContextId};
        let infra_context = serde_json::from_str::<InfraContextId>("\"V09\"")
            .expect("Failed to parse InfraContextId");
        assert_eq!(infra_context.0, InfraContext::Customer(9.into()));
        assert_eq!(
            serde_json::to_string(&infra_context).expect("Failed to serialize InfraContextId"),
            "\"V09\""
        );
    }
}