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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/*use tonic::{Request, Response, Status};
use actix_web::web::Data;
use ant_core::data::Wallet;
use crate::service::register_service::{Register as ServiceRegister, RegisterService};
use crate::controller::StoreType;
pub mod register_proto {
tonic::include_proto!("register");
}
use register_proto::register_service_server::RegisterService as RegisterServiceTrait;
pub use register_proto::register_service_server::RegisterServiceServer;
use register_proto::{Register, RegisterResponse, RegisterHistoryResponse, CreateRegisterRequest, UpdateRegisterRequest, GetRegisterRequest, GetRegisterHistoryRequest};
use crate::error::register_error::RegisterError;
pub struct RegisterHandler {
register_service: Data<RegisterService>,
evm_wallet: Data<Wallet>,
}
impl RegisterHandler {
pub fn new(register_service: Data<RegisterService>, evm_wallet: Data<Wallet>) -> Self {
Self { register_service, evm_wallet }
}
}
impl From<Register> for ServiceRegister {
fn from(r: Register) -> Self {
ServiceRegister::new(r.name, r.content, r.address)
}
}
impl From<ServiceRegister> for Register {
fn from(r: ServiceRegister) -> Self {
Register {
name: r.name,
content: r.content,
address: r.address,
}
}
}
impl From<RegisterError> for Status {
fn from(register_error: RegisterError) -> Self {
Status::internal(register_error.to_string())
}
}
#[tonic::async_trait]
impl RegisterServiceTrait for RegisterHandler {
async fn create_register(
&self,
request: Request<CreateRegisterRequest>,
) -> Result<Response<RegisterResponse>, Status> {
let req = request.into_inner();
let register = req.register.ok_or_else(|| Status::invalid_argument("Register is required"))?;
let result = self.register_service.create_register(
ServiceRegister::from(register),
self.evm_wallet.get_ref().clone(),
StoreType::from(req.store_type.unwrap_or_default()),
).await?;
Ok(Response::new(RegisterResponse {
register: Some(Register::from(result)),
}))
}
async fn update_register(
&self,
request: Request<UpdateRegisterRequest>,
) -> Result<Response<RegisterResponse>, Status> {
let req = request.into_inner();
let register = req.register.ok_or_else(|| Status::invalid_argument("Register is required"))?;
let result = self.register_service.update_register(
req.address,
ServiceRegister::from(register),
self.evm_wallet.get_ref().clone(),
StoreType::from(req.store_type.unwrap_or_default()),
).await?;
Ok(Response::new(RegisterResponse {
register: Some(Register::from(result)),
}))
}
async fn get_register(
&self,
request: Request<GetRegisterRequest>,
) -> Result<Response<RegisterResponse>, Status> {
let req = request.into_inner();
let result = self.register_service.get_register(req.address).await?;
Ok(Response::new(RegisterResponse {
register: Some(Register::from(result)),
}))
}
async fn get_register_history(
&self,
request: Request<GetRegisterHistoryRequest>,
) -> Result<Response<RegisterHistoryResponse>, Status> {
let req = request.into_inner();
let result = self.register_service.get_register_history(req.address).await?;
Ok(Response::new(RegisterHistoryResponse {
registers: result.into_iter().map(Register::from).collect(),
}))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::service::register_service::Register;
use crate::error::register_error::RegisterError;
use crate::error::GetError;
#[test]
fn test_from_register_proto_to_service() {
let proto_register = Register {
name: Some("test".to_string()),
content: "content".to_string(),
address: Some("address".to_string()),
};
let service_register = ServiceRegister::from(proto_register.clone());
assert_eq!(service_register.name, proto_register.name);
assert_eq!(service_register.content, proto_register.content);
assert_eq!(service_register.address, proto_register.address);
}
#[test]
fn test_from_service_to_register_proto() {
let service_register = ServiceRegister::new(
Some("test".to_string()),
"content".to_string(),
Some("address".to_string()),
);
let proto_register = Register::from(service_register.clone());
assert_eq!(proto_register.name, service_register.name);
assert_eq!(proto_register.content, service_register.content);
assert_eq!(proto_register.address, service_register.address);
}
#[test]
fn test_status_from_register_error() {
let error = RegisterError::GetError(GetError::RecordNotFound("not found".to_string()));
let status: Status = error.into();
assert_eq!(status.code(), tonic::Code::Internal);
assert!(status.message().contains("not found"));
}
}
*/