Browse Source

deps esse_types

pull/18/head
Sun 4 years ago
parent
commit
313dcf0bf4
  1. 6
      Cargo.toml
  2. 9
      lib/apps/domain/page.dart
  3. 1
      src/apps.rs
  4. 54
      src/apps/domain/layer.rs
  5. 72
      src/apps/domain/mod.rs
  6. 242
      src/apps/domain/models.rs
  7. 90
      src/apps/domain/rpc.rs
  8. 4
      src/apps/group_chat/mod.rs
  9. 20
      src/migrate.rs
  10. 17
      src/migrate/domain.rs
  11. 12
      src/storage.rs

6
Cargo.toml

@ -36,8 +36,10 @@ tokio = { version = "1", features = ["full"] } @@ -36,8 +36,10 @@ tokio = { version = "1", features = ["full"] }
tdn = { version = "0.5", default-features = false, features = ["full"] }
tdn_did = { git = "https://github.com/cypherlink/tdn_did", branch="main" }
tdn_storage = { git = "https://github.com/cypherlink/tdn_storage", branch="main" }
group-chat_types = { git = "https://github.com/cympletech/group-chat", branch="main" }
#group-chat-types = { path = "../group-chat/types" }
group-chat_types = { git = "https://github.com/cympletech/esse_types", branch="main" }
domain_types = { git = "https://github.com/cympletech/esse_types", branch="main" }
#group-chat_types = { path = "../esse_types/group_chat" }
#domain_types = { path = "../esse_types/domain" }
[target.'cfg(target_os="android")'.dependencies]
jni = { version = "0.19", default-features = false }

9
lib/apps/domain/page.dart

@ -13,6 +13,7 @@ import 'package:esse/widgets/audio_recorder.dart'; @@ -13,6 +13,7 @@ import 'package:esse/widgets/audio_recorder.dart';
import 'package:esse/widgets/show_contact.dart';
import 'package:esse/global.dart';
import 'package:esse/options.dart';
import 'package:esse/rpc.dart';
//import 'package:esse/apps/assistant/models.dart';
//import 'package:esse/apps/assistant/provider.dart';
@ -277,7 +278,13 @@ class _AddProviderScreenState extends State<_AddProviderScreen> { @@ -277,7 +278,13 @@ class _AddProviderScreenState extends State<_AddProviderScreen> {
controller: _addrController,
focus: _addrFocus),
),
ButtonText(action: () {}, text: lang.send),
ButtonText(action: () {
String addr = _addrController.text.trim();
if (addr.substring(0, 2) == '0x') {
addr = addr.substring(2);
}
rpc.send('domain-provider-add', [addr]);
}, text: lang.send),
]
);
}

1
src/apps.rs

@ -36,6 +36,7 @@ pub(crate) async fn app_layer_handle( @@ -36,6 +36,7 @@ pub(crate) async fn app_layer_handle(
match (fgid, mgid) {
(group_chat::GROUP_ID, _) => group_chat::layer_handle(layer, fgid, mgid, false, msg).await,
(_, group_chat::GROUP_ID) => group_chat::layer_handle(layer, fgid, mgid, true, msg).await,
(domain::GROUP_ID, _) => domain::layer_handle(layer, mgid, msg).await,
_ => chat::layer_handle(layer, fgid, mgid, msg).await,
}
}

54
src/apps/domain/layer.rs

@ -0,0 +1,54 @@ @@ -0,0 +1,54 @@
use std::path::PathBuf;
use std::sync::Arc;
use tdn::types::{
group::GroupId,
message::{RecvType, SendType},
primitive::{HandleResult, PeerAddr, Result},
};
use tokio::sync::RwLock;
use domain_types::{LayerPeerEvent, LayerServerEvent, ServerEvent};
use tdn_did::Proof;
use tdn_storage::local::DStorage;
use crate::layer::{Layer, Online};
use crate::storage::domain_db;
use super::models::{Name, Provider};
use super::{add_layer, rpc};
pub(crate) async fn handle(
layer: &Arc<RwLock<Layer>>,
ogid: GroupId,
msg: RecvType,
) -> Result<HandleResult> {
let results = HandleResult::new();
match msg {
RecvType::Connect(..)
| RecvType::Leave(..)
| RecvType::Result(..)
| RecvType::ResultConnect(..)
| RecvType::Stream(..) => {
info!("domain message nerver to here.")
}
RecvType::Event(addr, bytes) => {
// server & client handle it.
let LayerServerEvent(event, proof) = bincode::deserialize(&bytes)?;
match event {
ServerEvent::Status => {
println!("------ DEBUG DOMAIN SERVICE IS OK");
}
ServerEvent::Result(_name, _is_ok) => {}
ServerEvent::Info(_ugid, _uaddr, _uname, _ubio, _uavatar) => {}
ServerEvent::Response(_ugid, _uname, _is_ok) => {}
}
}
RecvType::Delivery(_t, _tid, _is_ok) => {
// MAYBE
}
}
Ok(results)
}

72
src/apps/domain/mod.rs

@ -1,50 +1,30 @@ @@ -1,50 +1,30 @@
use std::sync::Arc;
mod layer;
mod models;
pub use domain_types::DOMAIN_ID as GROUP_ID;
use domain_types::{LayerPeerEvent, PeerEvent};
use tdn::types::{
group::GroupId,
primitive::{HandleResult, PeerAddr},
rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
message::SendType,
primitive::{HandleResult, PeerAddr, Result},
};
use crate::rpc::RpcState;
pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
handler.add_method("domain-echo", |_, params, _| async move {
Ok(HandleResult::rpc(json!(params)))
});
handler.add_method(
"domain-add",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _provider = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
let _name = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-remove",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _id = params[0].as_i64().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-register",
|gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
let _provider = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
let _symbol = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
let _bio = params[3].as_str().ok_or(RpcError::ParseError)?.to_string();
let _me = state.group.read().await.clone_user(&gid)?;
// Send to remote domain service.
//
Ok(HandleResult::rpc(json!(params)))
},
);
use tdn_did::Proof;
/// Send to domain service.
#[inline]
pub(crate) fn add_layer(
results: &mut HandleResult,
addr: PeerAddr,
event: PeerEvent,
ogid: GroupId,
) -> Result<()> {
let proof = Proof::default();
let data = bincode::serialize(&LayerPeerEvent(event, proof))?;
let s = SendType::Event(0, addr, data);
results.layers.push((ogid, GROUP_ID, s));
Ok(())
}
pub(crate) mod rpc;
pub(crate) use layer::handle as layer_handle;
pub(crate) use rpc::new_rpc_handler;

242
src/apps/domain/models.rs

@ -0,0 +1,242 @@ @@ -0,0 +1,242 @@
use tdn::types::{
primitive::{PeerAddr, Result},
rpc::{json, RpcParam},
};
use tdn_storage::local::{DStorage, DsValue};
/// Provider Model.
pub(crate) struct Provider {
/// db auto-increment id.
id: i64,
/// name.
name: String,
/// address.
addr: PeerAddr,
/// is add ok.
is_ok: bool,
/// is default.
is_default: bool,
/// is actived.
is_actived: bool,
}
impl Provider {
pub fn to_rpc(&self) -> RpcParam {
json!([
self.id,
self.name,
self.addr.to_hex(),
self.is_ok,
self.is_default,
])
}
fn from_values(mut v: Vec<DsValue>) -> Self {
Self {
is_actived: v.pop().unwrap().as_bool(),
is_default: v.pop().unwrap().as_bool(),
is_ok: v.pop().unwrap().as_bool(),
addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
name: v.pop().unwrap().as_string(),
id: v.pop().unwrap().as_i64(),
}
}
/// use in rpc when load providers.
pub fn list(db: &DStorage) -> Result<Vec<Self>> {
let matrix =
db.query("SELECT id, name, addr, is_ok, is_default, is_actived FROM providers")?;
let mut providers = vec![];
for values in matrix {
providers.push(Self::from_values(values));
}
Ok(providers)
}
/// use in rpc when load provider by id.
pub fn get(db: &DStorage, id: &i64) -> Result<Self> {
let sql = format!(
"SELECT id, name, addr, is_ok, is_default, is_actived FROM providers WHERE id = {}",
id
);
let mut matrix = db.query(&sql)?;
if matrix.len() > 0 {
let values = matrix.pop().unwrap(); // safe unwrap()
return Ok(Self::from_values(values));
}
Err(anyhow!("provider is missing"))
}
/// insert a new provider.
pub fn get_by_addr(db: &DStorage, addr: &PeerAddr) -> Result<Self> {
let sql = format!(
"SELECT id, name, addr, is_ok, is_default, is_actived FROM providers WHERE addr = '{}'",
addr.to_hex()
);
let mut matrix = db.query(&sql)?;
if matrix.len() > 0 {
let values = matrix.pop().unwrap(); // safe unwrap()
return Ok(Self::from_values(values));
}
Err(anyhow!("provider is missing"))
}
pub fn insert(&mut self, db: &DStorage) -> Result<()> {
let mut unique_check = db.query(&format!(
"SELECT id from providers WHERE addr = '{}'",
self.addr.to_hex()
))?;
if unique_check.len() > 0 {
let id = unique_check.pop().unwrap().pop().unwrap().as_i64();
self.id = id;
let sql = format!("UPDATE providers SET name = '{}', addr = '{}', is_ok = {}, is_default = {}, is_actived = {} WHERE id = {}",
self.name,
self.addr.to_hex(),
self.is_ok,
self.is_default,
self.is_actived,
self.id
);
db.update(&sql)?;
} else {
let sql = format!(
"INSERT INTO providers (name, addr, is_ok, is_default, is_actived) VALUES ('{}', '{}', {}, {}, {})",
self.name,
self.addr.to_hex(),
self.is_ok,
self.is_default,
self.is_actived,
);
let id = db.insert(&sql)?;
self.id = id;
}
Ok(())
}
/// return if is closed
pub fn delete(db: &DStorage, id: &i64) -> Result<()> {
let sql = format!("UPDATE providers SET is_actived = false WHERE id = {}", id);
db.update(&sql)?;
Ok(())
}
}
/// Provider Model.
pub(crate) struct Name {
/// db auto-increment id.
id: i64,
/// provider database id.
provider: i64,
/// name.
name: String,
/// bio.
bio: String,
/// is add ok.
is_ok: bool,
/// is actived.
is_actived: bool,
}
impl Name {
pub fn to_rpc(&self) -> RpcParam {
json!([
self.id,
self.provider,
self.name,
self.bio,
self.is_ok,
self.is_actived,
])
}
fn from_values(mut v: Vec<DsValue>) -> Self {
Self {
is_actived: v.pop().unwrap().as_bool(),
is_ok: v.pop().unwrap().as_bool(),
bio: v.pop().unwrap().as_string(),
name: v.pop().unwrap().as_string(),
provider: v.pop().unwrap().as_i64(),
id: v.pop().unwrap().as_i64(),
}
}
/// use in rpc when load providers.
pub fn list(db: &DStorage) -> Result<Vec<Self>> {
let matrix = db.query("SELECT id, provider, name, bio, is_ok, is_actived FROM names")?;
let mut names = vec![];
for values in matrix {
names.push(Self::from_values(values));
}
Ok(names)
}
/// use in rpc when load provider by id.
pub fn get(db: &DStorage, id: &i64) -> Result<Self> {
let sql = format!(
"SELECT id, provider, name, bio, is_ok, is_actived FROM names WHERE id = {}",
id
);
let mut matrix = db.query(&sql)?;
if matrix.len() > 0 {
let values = matrix.pop().unwrap(); // safe unwrap()
return Ok(Self::from_values(values));
}
Err(anyhow!("name is missing"))
}
/// insert a new provider.
pub fn get_by_addr(db: &DStorage, addr: &PeerAddr) -> Result<Self> {
let sql = format!(
"SELECT id, name, addr, is_ok, is_default, is_actived FROM providers WHERE addr = '{}'",
addr.to_hex()
);
let mut matrix = db.query(&sql)?;
if matrix.len() > 0 {
let values = matrix.pop().unwrap(); // safe unwrap()
return Ok(Self::from_values(values));
}
Err(anyhow!("name is missing"))
}
pub fn insert(&mut self, db: &DStorage) -> Result<()> {
let mut unique_check = db.query(&format!(
"SELECT id from names WHERE provider = {} AND name = '{}'",
self.provider, self.name
))?;
if unique_check.len() > 0 {
let id = unique_check.pop().unwrap().pop().unwrap().as_i64();
self.id = id;
let sql = format!(
"UPDATE names SET bio = '{}', is_ok = {}, is_actived = {} WHERE id = {}",
self.bio, self.is_ok, self.is_actived, self.id
);
db.update(&sql)?;
} else {
let sql = format!(
"INSERT INTO names (provider, name, bio, is_ok, is_actived) VALUES ({}, '{}', '{}', {}, {})",
self.provider,
self.name,
self.bio,
self.is_ok,
self.is_actived,
);
let id = db.insert(&sql)?;
self.id = id;
}
Ok(())
}
/// delete the name.
pub fn delete(db: &DStorage, id: &i64) -> Result<()> {
let sql = format!("DELETE names WHERE id = {}", id);
db.delete(&sql)?;
Ok(())
}
/// active/suspend the name.
pub fn active(db: &DStorage, id: &i64, active: bool) -> Result<()> {
let sql = format!("UPDATE names SET is_actived = {} WHERE id = {}", active, id);
db.update(&sql)?;
Ok(())
}
}

90
src/apps/domain/rpc.rs

@ -0,0 +1,90 @@ @@ -0,0 +1,90 @@
use std::sync::Arc;
use tdn::types::{
group::GroupId,
primitive::{HandleResult, PeerAddr},
rpc::{json, RpcError, RpcHandler, RpcParam},
};
use domain_types::PeerEvent;
use super::add_layer;
use crate::rpc::RpcState;
pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
handler.add_method("domain-echo", |_, params, _| async move {
Ok(HandleResult::rpc(json!(params)))
});
handler.add_method(
"domain-provider-add",
|gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let provider = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
let mut results = HandleResult::new();
add_layer(&mut results, provider, PeerEvent::Check, gid)?;
Ok(results)
},
);
handler.add_method(
"domain-provider-default",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _id = params[0].as_i64().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-provider-remove",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _id = params[0].as_i64().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-register",
|gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
let _provider = params[0].as_i64().ok_or(RpcError::ParseError)?;
let _symbol = params[1].as_str().ok_or(RpcError::ParseError)?.to_string();
let _bio = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
let _me = state.group.read().await.clone_user(&gid)?;
// Send to remote domain service.
//
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-active",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _id = params[0].as_i64().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-remove",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _id = params[0].as_i64().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
handler.add_method(
"domain-search",
|_gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
let _name = params[0].as_str().ok_or(RpcError::ParseError)?;
Ok(HandleResult::rpc(json!(params)))
},
);
}

4
src/apps/group_chat/mod.rs

@ -4,13 +4,13 @@ mod models; @@ -4,13 +4,13 @@ mod models;
pub use group_chat_types::GROUP_CHAT_ID as GROUP_ID;
use tdn::types::{group::GroupId, message::SendType, primitive::HandleResult};
/// Group chat server to ESSE.
/// Send to group chat service.
#[inline]
pub(crate) fn add_layer(results: &mut HandleResult, gid: GroupId, msg: SendType) {
results.layers.push((gid, GROUP_ID, msg));
}
/// Group chat server to ESSE.
/// Send to group chat member.
#[inline]
pub fn add_server_layer(results: &mut HandleResult, gid: GroupId, msg: SendType) {
results.layers.push((GROUP_ID, gid, msg));

20
src/migrate.rs

@ -6,6 +6,7 @@ pub mod consensus; @@ -6,6 +6,7 @@ pub mod consensus;
mod account;
mod chat;
mod domain;
mod file;
mod group_chat;
mod service;
@ -14,6 +15,7 @@ mod session; @@ -14,6 +15,7 @@ mod session;
use account::ACCOUNT_VERSIONS;
use chat::CHAT_VERSIONS;
use consensus::CONSENSUS_VERSIONS;
use domain::DOMAIN_VERSIONS;
use file::FILE_VERSIONS;
use group_chat::GROUP_CHAT_VERSIONS;
use service::SERVICE_VERSIONS;
@ -45,6 +47,9 @@ pub(crate) const ASSISTANT_DB: &'static str = "assistant.db"; @@ -45,6 +47,9 @@ pub(crate) const ASSISTANT_DB: &'static str = "assistant.db";
/// Account's assistant database name
pub(crate) const GROUP_CHAT_DB: &'static str = "group_chat.db";
/// Account's domain database name
pub(crate) const DOMAIN_DB: &'static str = "domain.db";
pub(crate) fn main_migrate(path: &PathBuf) -> Result<()> {
let mut db_path = path.clone();
db_path.push(ACCOUNT_DB);
@ -112,6 +117,7 @@ pub(crate) fn main_migrate(path: &PathBuf) -> Result<()> { @@ -112,6 +117,7 @@ pub(crate) fn main_migrate(path: &PathBuf) -> Result<()> {
ASSISTANT_DB => ASSISTANT_VERSIONS.as_ref(),
GROUP_CHAT_DB => GROUP_CHAT_VERSIONS.as_ref(),
CHAT_DB => CHAT_VERSIONS.as_ref(),
DOMAIN_DB => DOMAIN_VERSIONS.as_ref(),
_ => {
continue;
}
@ -195,6 +201,12 @@ pub(crate) fn main_migrate(path: &PathBuf) -> Result<()> { @@ -195,6 +201,12 @@ pub(crate) fn main_migrate(path: &PathBuf) -> Result<()> {
CHAT_DB,
))?;
db.update(&format!(
"UPDATE migrates SET version = {} where db_name = '{}'",
DOMAIN_VERSIONS.len(),
DOMAIN_DB,
))?;
db.close()?;
}
@ -256,5 +268,13 @@ pub(crate) fn account_init_migrate(path: &PathBuf) -> Result<()> { @@ -256,5 +268,13 @@ pub(crate) fn account_init_migrate(path: &PathBuf) -> Result<()> {
for i in &CHAT_VERSIONS {
db.execute(i)?;
}
db.close()?;
let mut db_path = path.clone();
db_path.push(DOMAIN_DB);
let db = DStorage::open(db_path)?;
for i in &DOMAIN_VERSIONS {
db.execute(i)?;
}
db.close()
}

17
src/migrate/domain.rs

@ -0,0 +1,17 @@ @@ -0,0 +1,17 @@
#[rustfmt::skip]
pub(super) const DOMAIN_VERSIONS: [&str; 2] = [
"CREATE TABLE IF NOT EXISTS names(
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
provider INTEGER NOT NULL,
name TEXT NOT NULL,
bio TEXT NOT NULL,
is_ok INTEGER NOT NULL,
is_actived INTEGER NOT NULL);",
"CREATE TABLE IF NOT EXISTS providers(
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
name TEXT NOT NULL,
addr TEXT NOT NULL,
is_ok INTEGER NOT NULL,
is_default INTEGER NOT NULL,
is_actived INTEGER NOT NULL);",
];

12
src/storage.rs

@ -8,8 +8,8 @@ use tdn::types::{group::GroupId, primitive::Result}; @@ -8,8 +8,8 @@ use tdn::types::{group::GroupId, primitive::Result};
use tdn_storage::local::DStorage;
use crate::migrate::{
account_init_migrate, ACCOUNT_DB, ASSISTANT_DB, CHAT_DB, CONSENSUS_DB, FILE_DB, GROUP_CHAT_DB,
SERVICE_DB, SESSION_DB,
account_init_migrate, ACCOUNT_DB, ASSISTANT_DB, CHAT_DB, CONSENSUS_DB, DOMAIN_DB, FILE_DB,
GROUP_CHAT_DB, SERVICE_DB, SESSION_DB,
};
const FILES_DIR: &'static str = "files";
@ -378,6 +378,14 @@ pub(crate) fn group_chat_db(base: &PathBuf, gid: &GroupId) -> Result<DStorage> { @@ -378,6 +378,14 @@ pub(crate) fn group_chat_db(base: &PathBuf, gid: &GroupId) -> Result<DStorage> {
DStorage::open(db_path)
}
#[inline]
pub(crate) fn domain_db(base: &PathBuf, gid: &GroupId) -> Result<DStorage> {
let mut db_path = base.clone();
db_path.push(gid.to_hex());
db_path.push(DOMAIN_DB);
DStorage::open(db_path)
}
/// account independent db and storage directory.
pub(crate) async fn account_init(base: &PathBuf, gid: &GroupId) -> Result<()> {
let mut db_path = base.clone();

Loading…
Cancel
Save