jcoffey-dev
7dae9b29fd
Upstream commit: 474dd0229cb20cf513036619781ed97bd8073c3f Enterprise-only files removed or emptied: 63 Enterprise-only snippets removed: 117 in 50 files Dangling module declarations removed: 5 Cargo edits turning enterprise off: 14 Verification: clean Enterprise feature gates left for rebuilt features: 19 in 18 files Produced by tools/fork/strip.py. The full report is in docs/fork/strip-reports/ on main.
335 lines
10 KiB
Rust
335 lines
10 KiB
Rust
/*
|
|
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
|
|
*/
|
|
|
|
use crate::{
|
|
object::{AnyId, JmapObject, JmapObjectId},
|
|
request::{MaybeInvalid, deserialize::DeserializeArguments},
|
|
types::date::UTCDate,
|
|
};
|
|
use calcard::jscontact::{JSContactProperty, JSContactValue};
|
|
use jmap_tools::{JsonPointerItem, Key};
|
|
use std::borrow::Cow;
|
|
use types::{blob::BlobId, id::Id};
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct ContactCard;
|
|
|
|
impl JmapObject for ContactCard {
|
|
type Property = JSContactProperty<Id>;
|
|
|
|
type Element = JSContactValue<Id, BlobId>;
|
|
|
|
type Id = Id;
|
|
|
|
type Filter = ContactCardFilter;
|
|
|
|
type Comparator = ContactCardComparator;
|
|
|
|
type GetArguments = ();
|
|
|
|
type SetArguments<'de> = ();
|
|
|
|
type QueryArguments = ();
|
|
|
|
type CopyArguments = ();
|
|
|
|
type ParseArguments = ();
|
|
|
|
const ID_PROPERTY: Self::Property = JSContactProperty::Id;
|
|
}
|
|
|
|
impl JmapObjectId for JSContactValue<Id, BlobId> {
|
|
fn as_id(&self) -> Option<Id> {
|
|
if let JSContactValue::Id(id) = self {
|
|
Some(*id)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn as_any_id(&self) -> Option<AnyId> {
|
|
match self {
|
|
JSContactValue::Id(id) => Some(AnyId::Id(*id)),
|
|
JSContactValue::BlobId(id) => Some(AnyId::BlobId(id.clone())),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn as_id_ref(&self) -> Option<&str> {
|
|
match self {
|
|
JSContactValue::IdReference(r) => Some(r),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn try_set_id(&mut self, new_id: AnyId) -> bool {
|
|
match new_id {
|
|
AnyId::Id(id) => {
|
|
*self = JSContactValue::Id(id);
|
|
}
|
|
AnyId::BlobId(id) => {
|
|
*self = JSContactValue::BlobId(id);
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum ContactCardFilter {
|
|
InAddressBook(MaybeInvalid<Id>),
|
|
Uid(String),
|
|
HasMember(String),
|
|
Kind(String),
|
|
CreatedBefore(UTCDate),
|
|
CreatedAfter(UTCDate),
|
|
UpdatedBefore(UTCDate),
|
|
UpdatedAfter(UTCDate),
|
|
Text(String),
|
|
Name(String),
|
|
NameGiven(String),
|
|
NameSurname(String),
|
|
NameSurname2(String),
|
|
Nickname(String),
|
|
Organization(String),
|
|
Email(String),
|
|
Phone(String),
|
|
OnlineService(String),
|
|
Address(String),
|
|
Note(String),
|
|
_T(String),
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum ContactCardComparator {
|
|
Created,
|
|
Updated,
|
|
NameGiven,
|
|
NameSurname,
|
|
NameSurname2,
|
|
_T(String),
|
|
}
|
|
|
|
impl<'de> DeserializeArguments<'de> for ContactCardFilter {
|
|
fn deserialize_argument<A>(&mut self, key: &str, map: &mut A) -> Result<(), A::Error>
|
|
where
|
|
A: serde::de::MapAccess<'de>,
|
|
{
|
|
hashify::fnc_map!(key.as_bytes(),
|
|
b"inAddressBook" => {
|
|
*self = ContactCardFilter::InAddressBook(map.next_value()?);
|
|
},
|
|
b"uid" => {
|
|
*self = ContactCardFilter::Uid(map.next_value()?);
|
|
},
|
|
b"hasMember" => {
|
|
*self = ContactCardFilter::HasMember(map.next_value()?);
|
|
},
|
|
b"kind" => {
|
|
*self = ContactCardFilter::Kind(map.next_value()?);
|
|
},
|
|
b"createdBefore" => {
|
|
*self = ContactCardFilter::CreatedBefore(map.next_value()?);
|
|
},
|
|
b"createdAfter" => {
|
|
*self = ContactCardFilter::CreatedAfter(map.next_value()?);
|
|
},
|
|
b"updatedBefore" => {
|
|
*self = ContactCardFilter::UpdatedBefore(map.next_value()?);
|
|
},
|
|
b"updatedAfter" => {
|
|
*self = ContactCardFilter::UpdatedAfter(map.next_value()?);
|
|
},
|
|
b"text" => {
|
|
*self = ContactCardFilter::Text(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"name" => {
|
|
*self = ContactCardFilter::Name(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"name/given" => {
|
|
*self = ContactCardFilter::NameGiven(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"name/surname" => {
|
|
*self = ContactCardFilter::NameSurname(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"name/surname2" => {
|
|
*self = ContactCardFilter::NameSurname2(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"nickname" => {
|
|
*self = ContactCardFilter::Nickname(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"organization" => {
|
|
*self = ContactCardFilter::Organization(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"email" => {
|
|
*self = ContactCardFilter::Email(map.next_value()?);
|
|
},
|
|
b"phone" => {
|
|
*self = ContactCardFilter::Phone(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"onlineService" => {
|
|
*self = ContactCardFilter::OnlineService(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"address" => {
|
|
*self = ContactCardFilter::Address(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
b"note" => {
|
|
*self = ContactCardFilter::Note(map.next_value::<Cow<str>>()?.to_lowercase());
|
|
},
|
|
_ => {
|
|
*self = ContactCardFilter::_T(key.to_string());
|
|
let _ = map.next_value::<serde::de::IgnoredAny>()?;
|
|
}
|
|
);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<'de> DeserializeArguments<'de> for ContactCardComparator {
|
|
fn deserialize_argument<A>(&mut self, key: &str, map: &mut A) -> Result<(), A::Error>
|
|
where
|
|
A: serde::de::MapAccess<'de>,
|
|
{
|
|
if key == "property" {
|
|
let value = map.next_value::<Cow<str>>()?;
|
|
hashify::fnc_map!(value.as_bytes(),
|
|
b"created" => {
|
|
*self = ContactCardComparator::Created;
|
|
},
|
|
b"updated" => {
|
|
*self = ContactCardComparator::Updated;
|
|
},
|
|
b"name/given" => {
|
|
*self = ContactCardComparator::NameGiven;
|
|
},
|
|
b"name/surname" => {
|
|
*self = ContactCardComparator::NameSurname;
|
|
},
|
|
b"name/surname2" => {
|
|
*self = ContactCardComparator::NameSurname2;
|
|
},
|
|
_ => {
|
|
*self = ContactCardComparator::_T(value.to_string());
|
|
}
|
|
);
|
|
} else {
|
|
let _ = map.next_value::<serde::de::IgnoredAny>()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl ContactCardFilter {
|
|
pub fn into_string(self) -> Cow<'static, str> {
|
|
match self {
|
|
ContactCardFilter::InAddressBook(_) => "inAddressBook",
|
|
ContactCardFilter::Uid(_) => "uid",
|
|
ContactCardFilter::HasMember(_) => "hasMember",
|
|
ContactCardFilter::Kind(_) => "kind",
|
|
ContactCardFilter::CreatedBefore(_) => "createdBefore",
|
|
ContactCardFilter::CreatedAfter(_) => "createdAfter",
|
|
ContactCardFilter::UpdatedBefore(_) => "updatedBefore",
|
|
ContactCardFilter::UpdatedAfter(_) => "updatedAfter",
|
|
ContactCardFilter::Text(_) => "text",
|
|
ContactCardFilter::Name(_) => "name",
|
|
ContactCardFilter::NameGiven(_) => "name/given",
|
|
ContactCardFilter::NameSurname(_) => "name/surname",
|
|
ContactCardFilter::NameSurname2(_) => "name/surname2",
|
|
ContactCardFilter::Nickname(_) => "nickname",
|
|
ContactCardFilter::Organization(_) => "organization",
|
|
ContactCardFilter::Email(_) => "email",
|
|
ContactCardFilter::Phone(_) => "phone",
|
|
ContactCardFilter::OnlineService(_) => "onlineService",
|
|
ContactCardFilter::Address(_) => "address",
|
|
ContactCardFilter::Note(_) => "note",
|
|
ContactCardFilter::_T(s) => return Cow::Owned(s),
|
|
}
|
|
.into()
|
|
}
|
|
}
|
|
|
|
impl ContactCardComparator {
|
|
pub fn into_string(self) -> Cow<'static, str> {
|
|
match self {
|
|
ContactCardComparator::Created => "created",
|
|
ContactCardComparator::Updated => "updated",
|
|
ContactCardComparator::NameGiven => "name/given",
|
|
ContactCardComparator::NameSurname => "name/surname",
|
|
ContactCardComparator::NameSurname2 => "name/surname2",
|
|
ContactCardComparator::_T(s) => return Cow::Owned(s),
|
|
}
|
|
.into()
|
|
}
|
|
}
|
|
|
|
impl Default for ContactCardFilter {
|
|
fn default() -> Self {
|
|
ContactCardFilter::_T(String::new())
|
|
}
|
|
}
|
|
|
|
impl Default for ContactCardComparator {
|
|
fn default() -> Self {
|
|
ContactCardComparator::_T(String::new())
|
|
}
|
|
}
|
|
|
|
impl JmapObjectId for JSContactProperty<Id> {
|
|
fn as_id(&self) -> Option<Id> {
|
|
if let JSContactProperty::IdValue(id) = self {
|
|
Some(*id)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn as_any_id(&self) -> Option<AnyId> {
|
|
if let JSContactProperty::IdValue(id) = self {
|
|
Some(AnyId::Id(*id))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn as_id_ref(&self) -> Option<&str> {
|
|
match self {
|
|
JSContactProperty::IdReference(r) => Some(r),
|
|
JSContactProperty::Pointer(value) => {
|
|
let value = value.as_slice();
|
|
match (value.first(), value.get(1)) {
|
|
(
|
|
Some(JsonPointerItem::Key(Key::Property(
|
|
JSContactProperty::AddressBookIds,
|
|
))),
|
|
Some(JsonPointerItem::Key(Key::Property(JSContactProperty::IdReference(
|
|
r,
|
|
)))),
|
|
) => Some(r),
|
|
_ => None,
|
|
}
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn try_set_id(&mut self, new_id: AnyId) -> bool {
|
|
if let AnyId::Id(id) = new_id {
|
|
if let JSContactProperty::Pointer(value) = self {
|
|
let value = value.as_mut_slice();
|
|
if let Some(value) = value.get_mut(1) {
|
|
*value = JsonPointerItem::Key(Key::Property(JSContactProperty::IdValue(id)));
|
|
return true;
|
|
}
|
|
} else {
|
|
*self = JSContactProperty::IdValue(id);
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
}
|