144 lines
4.7 KiB
Rust
144 lines
4.7 KiB
Rust
use std::{
|
|
collections::hash_map::DefaultHasher,
|
|
hash::{Hash, Hasher},
|
|
};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use super::{
|
|
item_enum::ItemEnum, key_encryption::KeyEncryption, message_client::MessageClient,
|
|
pagination::Pagination, pcd_item_generic_enc::PcdItemGenericEnc, request::Request,
|
|
shared_peer::Peer, shared_process::Process,
|
|
};
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
pub struct Pcd {
|
|
pub request: Request, // Assuming Request is a predefined struct
|
|
pub item_list: Vec<PcdItemGenericEnc>,
|
|
pub pagination: Pagination, // Assuming Pagination is a predefined struct
|
|
}
|
|
|
|
impl Pcd {
|
|
pub const TYPE: &'static str = "pcd";
|
|
pub fn new(
|
|
request_item_name: Option<String>,
|
|
request_version: i64,
|
|
request_process_hash: String,
|
|
request_pcd_reference_hash: Option<String>,
|
|
request_item_reference_hash: Option<String>,
|
|
item_list: Vec<ItemEnum>,
|
|
pagination: Pagination,
|
|
process_public_enc_key: KeyEncryption,
|
|
member_private_enc_key: KeyEncryption,
|
|
) -> Self {
|
|
let request = Request::new(
|
|
request_item_name,
|
|
Self::TYPE.to_string(),
|
|
request_version,
|
|
request_process_hash,
|
|
request_pcd_reference_hash,
|
|
request_item_reference_hash,
|
|
);
|
|
|
|
// TODO: encrypt item_list
|
|
let mut item_enc_list: Vec<PcdItemGenericEnc> = Vec::new();
|
|
|
|
item_list.iter().for_each(|item| match item {
|
|
ItemEnum::Process(item_process) => {
|
|
let item_enc = item_process.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::Member(item_member) => {
|
|
let item_enc = item_member.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::Artefact(item_artefact) => {
|
|
let item_enc = item_artefact.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::Peer(item_peer) => {
|
|
let item_enc = item_peer.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::Payments(item_Payments) => {
|
|
let item_enc = item_Payments.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::Deposit(item_deposit) => {
|
|
let item_enc = item_deposit.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
ItemEnum::commit(item_commit) => {
|
|
let item_enc = item_commit.enc(
|
|
process_public_enc_key.clone(),
|
|
member_private_enc_key.clone(),
|
|
);
|
|
item_enc_list.push(item_enc);
|
|
}
|
|
});
|
|
|
|
Pcd {
|
|
request,
|
|
item_list: item_enc_list,
|
|
pagination,
|
|
}
|
|
}
|
|
pub fn display_info(&self) {
|
|
println!("Pcd:");
|
|
println!("Request:");
|
|
self.request.display_info();
|
|
|
|
println!("Item List:");
|
|
for item in &self.item_list {
|
|
item.display_info();
|
|
}
|
|
|
|
println!("Pagination:");
|
|
self.pagination.display_info();
|
|
}
|
|
|
|
pub fn to_message(
|
|
&self,
|
|
process_public_enc_key: KeyEncryption,
|
|
message_shared_peer_list: Vec<Peer>,
|
|
message_shared_process_list: Vec<Process>,
|
|
message_faucet_sp_address: String,
|
|
pow_pathern: String,
|
|
pow_difficulty: usize,
|
|
) -> MessageClient {
|
|
let mut hasher: DefaultHasher = DefaultHasher::new();
|
|
self.hash(&mut hasher);
|
|
let request_hash = hasher.finish().to_string();
|
|
let request_enc: String = process_public_enc_key.enc_pcd(self.clone()).to_string();
|
|
|
|
MessageClient::new(
|
|
request_enc,
|
|
request_hash,
|
|
message_shared_peer_list,
|
|
message_shared_process_list,
|
|
message_faucet_sp_address,
|
|
pow_pathern,
|
|
pow_difficulty,
|
|
)
|
|
}
|
|
}
|