use super::{AuthorisationKind, CmdError, DataAuthKind, QueryResponse};
use crate::{
Error, Map, MapAddress as Address, MapEntryActions as Changes,
MapPermissionSet as PermissionSet, PublicKey, XorName,
};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Hash, Eq, PartialEq, PartialOrd, Clone, Serialize, Deserialize)]
pub enum MapRead {
Get(Address),
GetValue {
address: Address,
key: Vec<u8>,
},
GetShell(Address),
GetVersion(Address),
ListEntries(Address),
ListKeys(Address),
ListValues(Address),
ListPermissions(Address),
ListUserPermissions {
address: Address,
user: PublicKey,
},
}
#[allow(clippy::large_enum_variant)]
#[derive(Hash, Eq, PartialEq, PartialOrd, Clone, Serialize, Deserialize)]
pub enum MapWrite {
New(Map),
Delete(Address),
Edit {
address: Address,
changes: Changes,
},
DelUserPermissions {
address: Address,
user: PublicKey,
version: u64,
},
SetUserPermissions {
address: Address,
user: PublicKey,
permissions: PermissionSet,
version: u64,
},
}
impl MapRead {
pub fn error(&self, error: Error) -> QueryResponse {
use MapRead::*;
match *self {
Get(_) => QueryResponse::GetMap(Err(error)),
GetValue { .. } => QueryResponse::GetMapValue(Err(error)),
GetShell(_) => QueryResponse::GetMapShell(Err(error)),
GetVersion(_) => QueryResponse::GetMapVersion(Err(error)),
ListEntries(_) => QueryResponse::ListMapEntries(Err(error)),
ListKeys(_) => QueryResponse::ListMapKeys(Err(error)),
ListValues(_) => QueryResponse::ListMapValues(Err(error)),
ListPermissions(_) => QueryResponse::ListMapPermissions(Err(error)),
ListUserPermissions { .. } => QueryResponse::ListMapUserPermissions(Err(error)),
}
}
pub fn authorisation_kind(&self) -> AuthorisationKind {
use MapRead::*;
match *self {
Get(_)
| GetValue { .. }
| GetShell(_)
| GetVersion(_)
| ListEntries(_)
| ListKeys(_)
| ListValues(_)
| ListPermissions(_)
| ListUserPermissions { .. } => AuthorisationKind::Data(DataAuthKind::PrivateRead),
}
}
pub fn dst_address(&self) -> XorName {
use MapRead::*;
match self {
Get(ref address)
| GetValue { ref address, .. }
| GetShell(ref address)
| GetVersion(ref address)
| ListEntries(ref address)
| ListKeys(ref address)
| ListValues(ref address)
| ListPermissions(ref address)
| ListUserPermissions { ref address, .. } => *address.name(),
}
}
}
impl fmt::Debug for MapRead {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
use MapRead::*;
write!(
formatter,
"Request::{}",
match *self {
Get(_) => "GetMap",
GetValue { .. } => "GetMapValue",
GetShell(_) => "GetMapShell",
GetVersion(_) => "GetMapVersion",
ListEntries(_) => "ListMapEntries",
ListKeys(_) => "ListMapKeys",
ListValues(_) => "ListMapValues",
ListPermissions(_) => "ListMapPermissions",
ListUserPermissions { .. } => "ListMapUserPermissions",
}
)
}
}
impl MapWrite {
pub fn error(&self, error: Error) -> CmdError {
CmdError::Data(error)
}
pub fn authorisation_kind(&self) -> AuthorisationKind {
AuthorisationKind::Data(DataAuthKind::Write)
}
pub fn dst_address(&self) -> XorName {
use MapWrite::*;
match self {
New(ref data) => *data.name(),
Delete(ref address)
| SetUserPermissions { ref address, .. }
| DelUserPermissions { ref address, .. }
| Edit { ref address, .. } => *address.name(),
}
}
}
impl fmt::Debug for MapWrite {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
use MapWrite::*;
write!(
formatter,
"Request::{}",
match *self {
New(_) => "NewMap",
Delete(_) => "DeleteMap",
SetUserPermissions { .. } => "SetMapUserPermissions",
DelUserPermissions { .. } => "DelMapUserPermissions",
Edit { .. } => "EditMap",
}
)
}
}