@ -25,19 +25,9 @@ use std::{
} ;
} ;
use indexmap ::IndexMap ;
use indexmap ::IndexMap ;
use serde ::{
use serde_json ::Value ;
de ::DeserializeOwned ,
ser ::{ Serialize , SerializeStruct , Serializer } ,
} ;
use serde_json ::{ value ::RawValue , Value } ;
use crate ::{
use crate ::jmap ::protocol ::Method ;
error ::Result ,
jmap ::{
argument ::Argument , comparator ::Comparator , deserialize_from_str , filters ,
protocol ::Method , session ::Session ,
} ,
} ;
pub type PatchObject = Value ;
pub type PatchObject = Value ;
@ -256,925 +246,3 @@ pub struct BlobGet;
impl Method < BlobObject > for BlobGet {
impl Method < BlobObject > for BlobGet {
const NAME : & ' static str = "Blob/get" ;
const NAME : & ' static str = "Blob/get" ;
}
}
/// #`get`
///
/// Objects of type `Foo` are fetched via a call to `Foo/get`.
///
/// It takes the following arguments:
///
/// - `account_id`: `Id`
///
/// The id of the account to use.
#[ derive(Clone, Debug, Deserialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct Get < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub account_id : Id < Account > ,
#[ serde(skip_serializing_if = " Option::is_none " ) ]
#[ serde(flatten) ]
pub ids : Option < Argument < Vec < Id < OBJ > > > > ,
#[ serde(skip_serializing_if = " Option::is_none " ) ]
pub properties : Option < Vec < String > > ,
#[ serde(skip) ]
_ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < OBJ > Get < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub fn new ( ) -> Self {
Self {
account_id : Id ::empty ( ) ,
ids : None ,
properties : None ,
_ph : PhantomData ,
}
}
_impl ! (
/// - accountId: `Id`
///
/// The id of the account to use.
account_id : Id < Account >
) ;
_impl ! (
/// - ids: `Option<Argument<Vec<String>>>`
///
/// The ids of the Foo objects to return. If `None`, then *all*
/// records of the data type are returned, if this is
/// supported for that data type and the number of records
/// does not exceed the `max_objects_in_get` limit.
ids : Option < Argument < Vec < Id < OBJ > > > >
) ;
_impl ! (
/// - properties: `Option<Vec<String>>`
///
/// If supplied, only the properties listed in the array are
/// returned for each `Foo` object. If `None`, all
/// properties of the object are returned. The `id`
/// property of the object is *always* returned, even if
/// not explicitly requested. If an invalid property is
/// requested, the call WILL be rejected with an
/// `invalid_arguments` error.
properties : Option < Vec < String > >
) ;
}
impl < OBJ > Default for Get < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
fn default ( ) -> Self {
Self ::new ( )
}
}
impl < OBJ : Object + Serialize + std ::fmt ::Debug > Serialize for Get < OBJ > {
fn serialize < S > ( & self , serializer : S ) -> std ::result ::Result < S ::Ok , S ::Error >
where
S : Serializer ,
{
let mut fields_no = 0 ;
if ! self . account_id . is_empty ( ) {
fields_no + = 1 ;
}
if self . ids . is_some ( ) {
fields_no + = 1 ;
}
if self . properties . is_some ( ) {
fields_no + = 1 ;
}
let mut state = serializer . serialize_struct ( "Get" , fields_no ) ? ;
if ! self . account_id . is_empty ( ) {
state . serialize_field ( "accountId" , & self . account_id ) ? ;
}
match self . ids . as_ref ( ) {
None = > { }
Some ( Argument ::Value ( ref v ) ) = > state . serialize_field ( "ids" , v ) ? ,
Some ( Argument ::ResultReference {
ref result_of ,
ref name ,
ref path ,
..
} ) = > {
#[ derive(Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
struct A < ' a > {
result_of : & ' a str ,
name : & ' a str ,
path : & ' a str ,
}
state . serialize_field (
"#ids" ,
& A {
result_of ,
name ,
path ,
} ,
) ? ;
}
}
if self . properties . is_some ( ) {
state . serialize_field ( "properties" , self . properties . as_ref ( ) . unwrap ( ) ) ? ;
}
state . end ( )
}
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct MethodResponse < ' a > {
#[ serde(borrow) ]
pub method_responses : Vec < & ' a RawValue > ,
#[ serde(default) ]
pub created_ids : IndexMap < Id < String > , Id < String > > ,
#[ serde(default) ]
pub session_state : State < Session > ,
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct GetResponse < OBJ : Object > {
pub account_id : Id < Account > ,
#[ serde(default = " State::default " ) ]
pub state : State < OBJ > ,
pub list : Vec < OBJ > ,
pub not_found : Vec < Id < OBJ > > ,
}
impl < OBJ : Object + DeserializeOwned > std ::convert ::TryFrom < & RawValue > for GetResponse < OBJ > {
type Error = crate ::error ::Error ;
fn try_from ( t : & RawValue ) -> Result < Self > {
let res : ( String , Self , String ) = deserialize_from_str ( t . get ( ) ) ? ;
assert_eq! ( & res . 0 , & format! ( "{}/get" , OBJ ::NAME ) ) ;
Ok ( res . 1 )
}
}
impl < OBJ : Object > GetResponse < OBJ > {
_impl ! ( get_mut account_id_mut , account_id : Id < Account > ) ;
_impl ! ( get_mut state_mut , state : State < OBJ > ) ;
_impl ! ( get_mut list_mut , list : Vec < OBJ > ) ;
_impl ! ( get_mut not_found_mut , not_found : Vec < Id < OBJ > > ) ;
}
#[ derive(Clone, Copy, Debug, Deserialize) ]
#[ serde(rename_all = " camelCase " ) ]
enum JmapError {
RequestTooLarge ,
InvalidArguments ,
InvalidResultReference ,
}
#[ derive(Clone, Debug, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct Query < F : filters ::FilterTrait < OBJ > , OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub account_id : Id < Account > ,
pub filter : Option < F > ,
pub sort : Option < Comparator < OBJ > > ,
#[ serde(default) ]
pub position : u64 ,
#[ serde(skip_serializing_if = " Option::is_none " ) ]
pub anchor : Option < String > ,
#[ serde(default) ]
#[ serde(skip_serializing_if = " u64_zero " ) ]
pub anchor_offset : u64 ,
#[ serde(skip_serializing_if = " Option::is_none " ) ]
pub limit : Option < u64 > ,
#[ serde(default = " bool_false " ) ]
pub calculate_total : bool ,
#[ serde(skip) ]
_ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < F : filters ::FilterTrait < OBJ > , OBJ > Query < F , OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub fn new ( ) -> Self {
Self {
account_id : Id ::empty ( ) ,
filter : None ,
sort : None ,
position : 0 ,
anchor : None ,
anchor_offset : 0 ,
limit : None ,
calculate_total : false ,
_ph : PhantomData ,
}
}
_impl ! ( account_id : Id < Account > ) ;
_impl ! ( filter : Option < F > ) ;
_impl ! ( sort : Option < Comparator < OBJ > > ) ;
_impl ! ( position : u64 ) ;
_impl ! ( anchor : Option < String > ) ;
_impl ! ( anchor_offset : u64 ) ;
_impl ! ( limit : Option < u64 > ) ;
_impl ! ( calculate_total : bool ) ;
}
impl < F : filters ::FilterTrait < OBJ > , OBJ > Default for Query < F , OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
fn default ( ) -> Self {
Self ::new ( )
}
}
pub fn u64_zero ( num : & u64 ) -> bool {
* num = = 0
}
pub fn bool_false ( ) -> bool {
false
}
pub fn bool_true ( ) -> bool {
true
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct QueryResponse < OBJ : Object > {
pub account_id : Id < Account > ,
pub query_state : String ,
pub can_calculate_changes : bool ,
pub position : u64 ,
pub ids : Vec < Id < OBJ > > ,
#[ serde(default) ]
pub total : u64 ,
#[ serde(default) ]
pub limit : u64 ,
#[ serde(skip) ]
_ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < OBJ : Object + DeserializeOwned > std ::convert ::TryFrom < & RawValue > for QueryResponse < OBJ > {
type Error = crate ::error ::Error ;
fn try_from ( t : & RawValue ) -> Result < Self > {
let res : ( String , Self , String ) = deserialize_from_str ( t . get ( ) ) ? ;
assert_eq! ( & res . 0 , & format! ( "{}/query" , OBJ ::NAME ) ) ;
Ok ( res . 1 )
}
}
impl < OBJ : Object > QueryResponse < OBJ > {
_impl ! ( get_mut ids_mut , ids : Vec < Id < OBJ > > ) ;
}
pub struct ResultField < M : Method < OBJ > , OBJ : Object > {
pub field : & ' static str ,
pub _ph : PhantomData < fn ( ) -> ( OBJ , M ) > ,
}
impl < M : Method < OBJ > , OBJ : Object > ResultField < M , OBJ > {
pub const fn new ( field : & ' static str ) -> Self {
Self {
field ,
_ph : PhantomData ,
}
}
}
impl < M : Method < OBJ > , OBJ : Object > From < & ' static str > for ResultField < M , OBJ > {
fn from ( field : & ' static str ) -> Self {
Self ::new ( field )
}
}
/// #`changes`
///
/// The `Foo/changes` method allows a client to efficiently update the state
/// of its Foo cache to match the new state on the server. It takes the
/// following arguments:
///
/// - accountId: `Id` The id of the account to use.
/// - sinceState: `String`
/// The current state of the client. This is the string that was
/// returned as the `state` argument in the `Foo/get` response. The
/// server will return the changes that have occurred since this
/// state.
///
/// - maxChanges: `UnsignedInt|null`
/// The maximum number of ids to return in the response. The server
/// MAY choose to return fewer than this value but MUST NOT return
/// more. If not given by the client, the server may choose how many
/// to return. If supplied by the client, the value MUST be a
/// positive integer greater than 0. If a value outside of this range
/// is given, the server MUST re
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
/* ch-ch-ch-ch-ch-Changes */
pub struct Changes < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub account_id : Id < Account > ,
pub since_state : State < OBJ > ,
#[ serde(skip_serializing_if = " Option::is_none " ) ]
pub max_changes : Option < u64 > ,
#[ serde(skip) ]
_ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < OBJ > Changes < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub fn new ( ) -> Self {
Self {
account_id : Id ::empty ( ) ,
since_state : State ::new ( ) ,
max_changes : None ,
_ph : PhantomData ,
}
}
_impl ! (
/// - accountId: `Id`
///
/// The id of the account to use.
account_id : Id < Account >
) ;
_impl ! (
/// - since_state: `String`
/// The current state of the client. This is the string that was
/// returned as the `state` argument in the `Foo/get` response. The
/// server will return the changes that have occurred since this
/// state.
since_state : State < OBJ >
) ;
_impl ! (
/// - max_changes: `UnsignedInt|null`
/// The maximum number of ids to return in the response. The server
/// MAY choose to return fewer than this value but MUST NOT return
/// more. If not given by the client, the server may choose how many
/// to return. If supplied by the client, the value MUST be a
/// positive integer greater than 0. If a value outside of this
/// range is given, the server MUST re
max_changes : Option < u64 >
) ;
}
impl < OBJ > Default for Changes < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
fn default ( ) -> Self {
Self ::new ( )
}
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct ChangesResponse < OBJ : Object > {
pub account_id : Id < Account > ,
pub old_state : State < OBJ > ,
pub new_state : State < OBJ > ,
pub has_more_changes : bool ,
pub created : Vec < Id < OBJ > > ,
pub updated : Vec < Id < OBJ > > ,
pub destroyed : Vec < Id < OBJ > > ,
#[ serde(skip) ]
pub _ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < OBJ : Object + DeserializeOwned > std ::convert ::TryFrom < & RawValue > for ChangesResponse < OBJ > {
type Error = crate ::error ::Error ;
fn try_from ( t : & RawValue ) -> Result < Self > {
let res : ( String , Self , String ) = deserialize_from_str ( t . get ( ) ) ? ;
assert_eq! ( & res . 0 , & format! ( "{}/changes" , OBJ ::NAME ) ) ;
Ok ( res . 1 )
}
}
impl < OBJ : Object > ChangesResponse < OBJ > {
_impl ! ( get_mut account_id_mut , account_id : Id < Account > ) ;
_impl ! ( get_mut old_state_mut , old_state : State < OBJ > ) ;
_impl ! ( get_mut new_state_mut , new_state : State < OBJ > ) ;
_impl ! ( get has_more_changes , has_more_changes : bool ) ;
_impl ! ( get_mut created_mut , created : Vec < Id < OBJ > > ) ;
_impl ! ( get_mut updated_mut , updated : Vec < Id < OBJ > > ) ;
_impl ! ( get_mut destroyed_mut , destroyed : Vec < Id < OBJ > > ) ;
}
/// #`set`
///
/// Modifying the state of Foo objects on the server is done via the
/// `Foo/set` method. This encompasses creating, updating, and
/// destroying Foo records. This allows the server to sort out ordering
/// and dependencies that may exist if doing multiple operations at once
/// (for example, to ensure there is always a minimum number of a certain
/// record type).
#[ derive(Clone, Debug, Deserialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct Set < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
/// o accountId: `Id`
///
/// The id of the account to use.
pub account_id : Id < Account > ,
/// o ifInState: `String|null`
///
/// This is a state string as returned by the `Foo/get` method
/// (representing the state of all objects of this type in the
/// account). If supplied, the string must match the current state;
/// otherwise, the method will be aborted and a `stateMismatch` error
/// returned. If null, any changes will be applied to the current
/// state.
pub if_in_state : Option < State < OBJ > > ,
/// o create: `Id[Foo]|null`
///
/// A map of a *creation id* (a temporary id set by the client) to Foo
/// objects, or null if no objects are to be created.
///
/// The Foo object type definition may define default values for
/// properties. Any such property may be omitted by the client.
///
/// The client MUST omit any properties that may only be set by the
/// server (for example, the `id` property on most object types).
pub create : Option < IndexMap < Argument < Id < OBJ > > , OBJ > > ,
/// o update: `Id[PatchObject]|null`
///
/// A map of an id to a Patch object to apply to the current Foo
/// object with that id, or null if no objects are to be updated.
///
/// A [`PatchObject`] is of type `String[*]` and represents an unordered
/// set of patches. The keys are a path in JSON Pointer format
/// `RFC6901`, with an implicit leading `/` (i.e., prefix each key
/// with `/` before applying the JSON Pointer evaluation algorithm).
///
/// All paths MUST also conform to the following restrictions; if
/// there is any violation, the update MUST be rejected with an
/// `invalidPatch` error:
/// * The pointer MUST NOT reference inside an array (i.e., you MUST NOT
/// insert/delete from an array; the array MUST be replaced in its
/// entirety instead).
///
/// * All parts prior to the last (i.e., the value after the final slash)
/// MUST already exist on the object being patched.
///
/// * There MUST NOT be two patches in the [`PatchObject`] where the
/// pointer of one is the prefix of the pointer of the other, e.g.,
/// `alerts/1/offset` and `alerts`.
///
/// The value associated with each pointer determines how to apply
/// that patch:
///
/// * If null, set to the default value if specified for this property;
/// otherwise, remove the property from the patched object. If the key
/// is not present in the parent, this a no-op.
///
/// * Anything else: The value to set for this property (this may be a
/// replacement or addition to the object being patched).
///
/// Any server-set properties MAY be included in the patch if their
/// value is identical to the current server value (before applying
/// the patches to the object). Otherwise, the update MUST be
/// rejected with an `invalidProperties` [`SetError`].
///
/// This patch definition is designed such that an entire Foo object
/// is also a valid [`PatchObject`]. The client may choose to optimise
/// network usage by just sending the diff or may send the whole
/// object; the server processes it the same either way.
pub update : Option < IndexMap < Argument < Id < OBJ > > , PatchObject > > ,
/// o destroy: `Id[]|null`
///
/// A list of ids for Foo objects to permanently delete, or null if no
/// objects are to be destroyed.
pub destroy : Option < Vec < Argument < Id < OBJ > > > > ,
}
impl < OBJ > Set < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub fn new ( ) -> Self {
Self {
account_id : Id ::empty ( ) ,
if_in_state : None ,
create : None ,
update : None ,
destroy : None ,
}
}
_impl ! ( account_id : Id < Account > ) ;
_impl ! (
/// o ifInState: `String|null`
///
/// This is a state string as returned by the `Foo/get` method
/// (representing the state of all objects of this type in the
/// account). If supplied, the string must match the current state;
/// otherwise, the method will be aborted and a `stateMismatch` error
/// returned. If null, any changes will be applied to the current
/// state.
if_in_state : Option < State < OBJ > >
) ;
_impl ! ( update : Option < IndexMap < Argument < Id < OBJ > > , PatchObject > > ) ;
_impl ! ( create : Option < IndexMap < Argument < Id < OBJ > > , OBJ > > ) ;
_impl ! ( destroy : Option < Vec < Argument < Id < OBJ > > > > ) ;
}
impl < OBJ > Default for Set < OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
fn default ( ) -> Self {
Self ::new ( )
}
}
impl < OBJ : Object + Serialize + std ::fmt ::Debug > Serialize for Set < OBJ > {
fn serialize < S > ( & self , serializer : S ) -> std ::result ::Result < S ::Ok , S ::Error >
where
S : Serializer ,
{
let fields_no = 5 ;
let mut state = serializer . serialize_struct ( "Set" , fields_no ) ? ;
state . serialize_field ( "accountId" , & self . account_id ) ? ;
state . serialize_field ( "ifInState" , & self . if_in_state ) ? ;
state . serialize_field ( "update" , & self . update ) ? ;
state . serialize_field ( "destroy" , & self . destroy ) ? ;
if let Some ( ref m ) = self . create {
let map = m
. into_iter ( )
. map ( | ( k , v ) | {
let mut v = serde_json ::json ! ( v ) ;
if let Some ( ref mut obj ) = v . as_object_mut ( ) {
obj . remove ( "id" ) ;
}
( k , v )
} )
. collect ::< IndexMap < _ , Value > > ( ) ;
state . serialize_field ( "create" , & map ) ? ;
} else {
state . serialize_field ( "create" , & self . create ) ? ;
}
state . end ( )
}
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct SetResponse < OBJ : Object > {
/// o accountId: `Id`
///
/// The id of the account used for the call.
pub account_id : Id < Account > ,
/// o oldState: `String|null`
///
/// The state string that would have been returned by `Foo/get` before
/// making the requested changes, or null if the server doesn't know
/// what the previous state string was.
pub old_state : Option < State < OBJ > > ,
/// o newState: `String`
///
/// The state string that will now be returned by `Foo/get`.
pub new_state : State < OBJ > ,
/// o created: `Id[Foo]|null`
///
/// A map of the creation id to an object containing any properties of
/// the created Foo object that were not sent by the client. This
/// includes all server-set properties (such as the `id` in most
/// object types) and any properties that were omitted by the client
/// and thus set to a default by the server.
///
/// This argument is null if no Foo objects were successfully created.
pub created : Option < IndexMap < Id < OBJ > , OBJ > > ,
/// o updated: `Id[Foo|null]|null`
///
/// The keys in this map are the ids of all Foos that were
/// successfully updated.
///
/// The value for each id is a Foo object containing any property that
/// changed in a way *not* explicitly requested by the [`PatchObject`]
/// sent to the server, or null if none. This lets the client know of
/// any changes to server-set or computed properties.
///
/// This argument is null if no Foo objects were successfully updated.
pub updated : Option < IndexMap < Id < OBJ > , Option < OBJ > > > ,
/// o destroyed: `Id[]|null`
///
/// A list of Foo ids for records that were successfully destroyed, or
/// null if none.
pub destroyed : Option < Vec < Id < OBJ > > > ,
/// o notCreated: `Id[SetError]|null`
///
/// A map of the creation id to a [`SetError`] object for each record that
/// failed to be created, or null if all successful.
pub not_created : Option < Vec < SetError > > ,
/// o notUpdated: `Id[SetError]|null`
///
/// A map of the Foo id to a [`SetError`] object for each record that
/// failed to be updated, or null if all successful.
pub not_updated : Option < Vec < SetError > > ,
/// o notDestroyed: `Id[SetError]|null`
///
/// A map of the Foo id to a [`SetError`] object for each record that
/// failed to be destroyed, or null if all successful.//
pub not_destroyed : Option < Vec < SetError > > ,
}
impl < OBJ : Object + DeserializeOwned > std ::convert ::TryFrom < & RawValue > for SetResponse < OBJ > {
type Error = crate ::error ::Error ;
fn try_from ( t : & RawValue ) -> Result < Self > {
let res : ( String , Self , String ) = deserialize_from_str ( t . get ( ) ) ? ;
assert_eq! ( & res . 0 , & format! ( "{}/set" , OBJ ::NAME ) ) ;
Ok ( res . 1 )
}
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
#[ serde(tag = " type " , content = " description " ) ]
pub enum SetError {
/// (create; update; destroy). The create/update/destroy would violate an
/// ACL or other permissions policy.
Forbidden ( Option < String > ) ,
/// (create; update). The create would exceed a server- defined limit on
/// the number or total size of objects of this type.
OverQuota ( Option < String > ) ,
/// (create; update). The create/update would result in an object that
/// exceeds a server-defined limit for the maximum size of a single object
/// of this type.
TooLarge ( Option < String > ) ,
/// (create). Too many objects of this type have been created recently, and
/// a server-defined rate limit has been reached. It may work if tried
/// again later.
RateLimit ( Option < String > ) ,
/// (update; destroy). The id given to update/destroy cannot be found.
NotFound ( Option < String > ) ,
/// (update). The [`PatchObject`] given to update the record was not a
/// valid patch (see the patch description).
InvalidPatch ( Option < String > ) ,
/// (update). The client requested that an object be both updated and
/// destroyed in the same /set request, and the server has decided to
/// therefore ignore the update.
WillDestroy ( Option < String > ) ,
/// (create; update). The record given is invalid in some way.
InvalidProperties {
description : Option < String > ,
properties : Vec < String > ,
} ,
/// (create; destroy). This is a singleton type, so you cannot create
/// another one or destroy the existing one.
Singleton ( Option < String > ) ,
RequestTooLarge ( Option < String > ) ,
StateMismatch ( Option < String > ) ,
}
impl std ::fmt ::Display for SetError {
fn fmt ( & self , fmt : & mut std ::fmt ::Formatter ) -> std ::fmt ::Result {
use SetError ::* ;
match self {
Forbidden ( Some ( description ) ) = > write! ( fmt , "Forbidden: {}" , description ) ,
Forbidden ( None ) = > write! ( fmt , "Forbidden" ) ,
OverQuota ( Some ( description ) ) = > write! ( fmt , "OverQuota: {}" , description ) ,
OverQuota ( None ) = > write! ( fmt , "OverQuota" ) ,
TooLarge ( Some ( description ) ) = > write! ( fmt , "TooLarge: {}" , description ) ,
TooLarge ( None ) = > write! ( fmt , "TooLarge" ) ,
RateLimit ( Some ( description ) ) = > write! ( fmt , "RateLimit: {}" , description ) ,
RateLimit ( None ) = > write! ( fmt , "RateLimit" ) ,
NotFound ( Some ( description ) ) = > write! ( fmt , "NotFound: {}" , description ) ,
NotFound ( None ) = > write! ( fmt , "NotFound" ) ,
InvalidPatch ( Some ( description ) ) = > write! ( fmt , "InvalidPatch: {}" , description ) ,
InvalidPatch ( None ) = > write! ( fmt , "InvalidPatch" ) ,
WillDestroy ( Some ( description ) ) = > write! ( fmt , "WillDestroy: {}" , description ) ,
WillDestroy ( None ) = > write! ( fmt , "WillDestroy" ) ,
InvalidProperties {
description : Some ( description ) ,
properties ,
} = > write! (
fmt ,
"InvalidProperties: {}, {}" ,
description ,
properties . join ( "," )
) ,
InvalidProperties {
description : None ,
properties ,
} = > write! ( fmt , "InvalidProperties: {}" , properties . join ( "," ) ) ,
Singleton ( Some ( description ) ) = > write! ( fmt , "Singleton: {}" , description ) ,
Singleton ( None ) = > write! ( fmt , "Singleton" ) ,
RequestTooLarge ( Some ( description ) ) = > write! ( fmt , "RequestTooLarge: {}" , description ) ,
RequestTooLarge ( None ) = > write! ( fmt , "RequestTooLarge" ) ,
StateMismatch ( Some ( description ) ) = > write! ( fmt , "StateMismatch: {}" , description ) ,
StateMismatch ( None ) = > write! ( fmt , "StateMismatch" ) ,
}
}
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct UploadResponse {
/// o accountId: `Id`
///
/// The id of the account used for the call.
pub account_id : Id < Account > ,
/// o blobId: `Id`
///
/// The id representing the binary data uploaded. The data for this id is
/// immutable. The id *only* refers to the binary data, not any
/// metadata.
pub blob_id : Id < BlobObject > ,
/// o type: `String`
///
/// The media type of the file (as specified in `RFC6838`,
/// Section 4.2) as set in the Content-Type header of the upload HTTP
/// request.
#[ serde(rename = " type " ) ]
pub _type : String ,
/// o size: `UnsignedInt`
///
/// The size of the file in octets.
pub size : usize ,
}
/// #`queryChanges`
///
/// The `Foo/queryChanges` method allows a client to efficiently update
/// the state of a cached query to match the new state on the server. It
/// takes the following arguments:
#[ derive(Clone, Debug, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct QueryChanges < F : filters ::FilterTrait < OBJ > , OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub account_id : Id < Account > ,
pub filter : Option < F > ,
pub sort : Option < Comparator < OBJ > > ,
/// sinceQueryState: `String`
///
/// The current state of the query in the client. This is the string
/// that was returned as the `queryState` argument in the `Foo/query`
/// response with the same sort/filter. The server will return the
/// changes made to the query since this state.
pub since_query_state : String ,
/// o maxChanges: `UnsignedInt|null`
///
/// The maximum number of changes to return in the response. See
/// error descriptions below for more details.
pub max_changes : Option < usize > ,
/// o upToId: `Id|null`
///
/// The last (highest-index) id the client currently has cached from
/// the query results. When there are a large number of results, in a
/// common case, the client may have only downloaded and cached a
/// small subset from the beginning of the results. If the sort and
/// filter are both only on immutable properties, this allows the
/// server to omit changes after this point in the results, which can
/// significantly increase efficiency. If they are not immutable,
/// this argument is ignored.
pub up_to_id : Option < Id < OBJ > > ,
/// o calculateTotal: `Boolean` (default: false)
///
/// Does the client wish to know the total number of results now in
/// the query? This may be slow and expensive for servers to
/// calculate, particularly with complex filters, so clients should
/// take care to only request the total when needed.
#[ serde(default = " bool_false " ) ]
pub calculate_total : bool ,
#[ serde(skip) ]
_ph : PhantomData < fn ( ) -> OBJ > ,
}
impl < F : filters ::FilterTrait < OBJ > , OBJ > QueryChanges < F , OBJ >
where
OBJ : Object + std ::fmt ::Debug + Serialize ,
{
pub fn new ( account_id : Id < Account > , since_query_state : String ) -> Self {
Self {
account_id ,
filter : None ,
sort : None ,
since_query_state ,
max_changes : None ,
up_to_id : None ,
calculate_total : false ,
_ph : PhantomData ,
}
}
_impl ! ( filter : Option < F > ) ;
_impl ! ( sort : Option < Comparator < OBJ > > ) ;
_impl ! ( max_changes : Option < usize > ) ;
_impl ! ( up_to_id : Option < Id < OBJ > > ) ;
_impl ! ( calculate_total : bool ) ;
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct QueryChangesResponse < OBJ : Object > {
/// The id of the account used for the call.
pub account_id : Id < Account > ,
/// This is the `sinceQueryState` argument echoed back; that is, the state
/// from which the server is returning changes.
pub old_query_state : String ,
/// This is the state the query will be in after applying the set of changes
/// to the old state.
pub new_query_state : String ,
/// The total number of Foos in the results (given the `filter`). This
/// argument MUST be omitted if the `calculateTotal` request argument is not
/// true.
#[ serde(default) ]
pub total : Option < usize > ,
/// The `id` for every Foo that was in the query results in the old
/// state and that is not in the results in the new state.
/// If the server cannot calculate this exactly, the server MAY return
/// the ids of extra Foos in addition that may have been in the old
/// results but are not in the new results.
/// If the sort and filter are both only on immutable properties and
/// an `upToId` is supplied and exists in the results, any ids that
/// were removed but have a higher index than `upToId` SHOULD be
/// omitted.
/// If the `filter` or `sort` includes a mutable property, the server
/// MUST include all Foos in the current results for which this
/// property may have changed. The position of these may have moved
/// in the results, so they must be reinserted by the client to ensure
/// its query cache is correct.
pub removed : Vec < Id < OBJ > > ,
/// The id and index in the query results (in the new state) for every
/// Foo that has been added to the results since the old state AND
/// every Foo in the current results that was included in the
/// `removed` array (due to a filter or sort based upon a mutable
/// property).
/// If the sort and filter are both only on immutable properties and
/// an `upToId` is supplied and exists in the results, any ids that
/// were added but have a higher index than `upToId` SHOULD be
/// omitted.
/// The array MUST be sorted in order of index, with the lowest index
/// first.
/// An [`AddedItem`] object has the following properties:
/// * id: `Id`
/// * index: `UnsignedInt`
/// The result of this is that if the client has a cached sparse array of
/// Foo ids corresponding to the results in the old state, then:
/// fooIds = [ `id1`, `id2`, null, null, `id3`, `id4`, null, null, null ]
/// If it *splices out* all ids in the removed array that it has in its
/// cached results, then:
/// removed = [ `id2`, `id31`, ... ];
/// fooIds => [ `id1`, null, null, `id3`, `id4`, null, null, null ]
/// and *splices in* (one by one in order, starting with the lowest
/// index) all of the ids in the added array:
/// added = [{ id: `id5`, index: 0, ... }];
/// fooIds => [ `id5`, `id1`, null, null, `id3`, `id4`, null, null, null ]
/// and *truncates* or *extends* to the new total length, then the
/// results will now be in the new state.
/// Note: splicing in adds the item at the given index, incrementing the
/// index of all items previously at that or a higher index. Splicing
/// out is the inverse, removing the item and decrementing the index of
/// every item after it in the array.
pub added : Vec < AddedItem < OBJ > > ,
}
#[ derive(Clone, Debug, Deserialize, Serialize) ]
#[ serde(rename_all = " camelCase " ) ]
pub struct AddedItem < OBJ : Object > {
pub id : Id < OBJ > ,
pub index : usize ,
}