domain: add provider

lib/apps/domain/models.dart

@@ -0,0 +1,35 @@
+class ProviderServer {
+  int id;
+  String name;
+  String addr;
+  bool isOk;
+  bool isDefault;
+  bool isProxy;
+  bool isActived;
+
+  ProviderServer.fromList(List params):
+    this.id = params[0],
+    this.name = params[1],
+    this.addr = params[2],
+    this.isOk = params[3],
+    this.isDefault = params[4],
+    this.isProxy = params[5],
+    this.isActived = params[6];
+}
+
+class Name {
+  int id;
+  int provider;
+  String name;
+  String bio;
+  bool isOk;
+  bool isActived;
+
+  Name.fromList(List params):
+    this.id = params[0],
+    this.provider = params[1],
+    this.name = params[2],
+    this.bio = params[3],
+    this.isOk = params[4],
+    this.isActived = params[5];
+}

lib/apps/domain/page.dart

@@ -2,6 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
 import 'package:esse/utils/adaptive.dart';
+import 'package:esse/utils/better_print.dart';
 import 'package:esse/utils/pick_image.dart';
 import 'package:esse/utils/pick_file.dart';
 import 'package:esse/l10n/localizations.dart';
@@ -15,8 +16,7 @@ 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';
+import 'package:esse/apps/domain/models.dart';
 
 class DomainDetail extends StatefulWidget {
   const DomainDetail({Key? key}) : super(key: key);
@@ -29,6 +29,38 @@ class _DomainDetailState extends State<DomainDetail> {
   bool _showProviders = false;
   bool _listHome = true;
 
+  Map<int, ProviderServer> _providers = {};
+  List<Name> _names = [];
+
+  _domainList(List params) {
+    this._providers.clear();
+    params[0].forEach((param) {
+        this._providers[param[0]] = ProviderServer.fromList(param);
+    });
+    this._names.clear();
+    params[1].forEach((param) {
+        this._names.add(Name.fromList(param));
+    });
+    setState(() {});
+  }
+
+  _domainProviderAdd(List params) {
+    setState(() {
+        this._providers[params[0]] = ProviderServer.fromList(params);
+    });
+  }
+
+  @override
+  void initState() {
+    super.initState();
+
+    // resigter rpc for current page.
+    rpc.addListener('domain-list', _domainList, false);
+    rpc.addListener('domain-provider-add', _domainProviderAdd, false);
+
+    rpc.send('domain-list', []);
+  }
+
   @override
   Widget build(BuildContext context) {
     final color = Theme.of(context).colorScheme;
@@ -62,7 +94,7 @@ class _DomainDetailState extends State<DomainDetail> {
           child: Container(
             padding: const EdgeInsets.symmetric(horizontal: 20.0),
             child: this._listHome
-            ? (this._showProviders ? _ListProviderScreen() : _ListNameScreen())
+            ? (this._showProviders ? _ListProviderScreen(this._providers) : _ListNameScreen(this._providers, this._names))
             : (this._showProviders ? _AddProviderScreen() : _RegisterScreen()),
       ))),
       floatingActionButton: FloatingActionButton(
@@ -78,7 +110,10 @@ class _DomainDetailState extends State<DomainDetail> {
 }
 
 class _ListNameScreen extends StatelessWidget {
-  const _ListNameScreen({Key? key}) : super(key: key);
+  final Map<int, ProviderServer> providers;
+  final List<Name> names;
+
+  const _ListNameScreen(this.providers, this.names);
 
   Widget _nameItem(int id, String name, String provider, bool isActive, ColorScheme color) {
     return Card(
@@ -112,17 +147,17 @@ class _ListNameScreen extends StatelessWidget {
     final color = Theme.of(context).colorScheme;
 
     return Column(
-      children: [
-        _nameItem(0, "Sun", "domain.esse", true, color),
-        _nameItem(0, "Huachuang", "domain.esse", false, color),
-        _nameItem(0, "sun", "eth.esse", true, color),
-      ]
+      children: this.names.map(
+        (name) => _nameItem(name.id, name.name, providers[name.provider]!.name, name.isActived, color)
+      ).toList(),
     );
   }
 }
 
 class _ListProviderScreen extends StatelessWidget {
-  const _ListProviderScreen({Key? key}) : super(key: key);
+  final Map<int, ProviderServer> providers;
+
+  const _ListProviderScreen(this.providers);
 
   Widget _providerItem(int id, String name, String address, bool isDefault, ColorScheme color, AppLocalizations lang) {
     return Card(
@@ -164,10 +199,9 @@ class _ListProviderScreen extends StatelessWidget {
     final lang = AppLocalizations.of(context);
 
     return Column(
-      children: [
-        _providerItem(0, "domain.esse", "0x89d240...77407b0e", true, color, lang),
-        _providerItem(0, "eth.esse", "0x89d240...77407b0e", false, color, lang),
-      ]
+      children: this.providers.values.map(
+        (provider) => _providerItem(provider.id, provider.name, addrPrint(provider.addr), provider.isDefault, color, lang)
+      ).toList(),
     );
   }
 }

lib/utils/better_print.dart

@@ -9,3 +9,31 @@ String betterPrint(String? info) {
     return info;
   }
 }
+
+String gidPrint(String? gid) {
+  if (gid == null) {
+    return '';
+  }
+
+  final info = gid.toUpperCase();
+  final len = info.length;
+  if (len > 8) {
+    return 'EH' + info.substring(0, 6) + '...' + info.substring(len - 4, len);
+  } else {
+    return info;
+  }
+}
+
+String addrPrint(String? addr) {
+  if (addr == null) {
+    return '';
+  }
+
+  final info = addr.toLowerCase();
+  final len = info.length;
+  if (len > 8) {
+    return '0x' + info.substring(0, 8) + '...' + info.substring(len - 6, len);
+  } else {
+    return info;
+  }
+}

src/apps/domain/layer.rs

@@ -36,13 +36,38 @@ pub(crate) async fn handle(
             // server & client handle it.
             let LayerServerEvent(event, proof) = bincode::deserialize(&bytes)?;
 
+            let db = domain_db(layer.read().await.base(), &ogid)?;
+
             match event {
-                ServerEvent::Status => {
-                    println!("------ DEBUG DOMAIN SERVICE IS OK");
+                ServerEvent::Status(name, support_request) => {
+                    println!(
+                        "------ DEBUG DOMAIN SERVICE IS {}, request: {}",
+                        name, support_request
+                    );
+
+                    let mut provider = Provider::get_by_addr(&db, &addr)?;
+                    provider.ok(&db, name, support_request);
+
+                    // TODO UI: add new provider.
+                }
+                ServerEvent::Result(name, is_ok) => {
+                    let provider = Provider::get_by_addr(&db, &addr)?;
+                    let mut name = Name::get_by_name_provider(&db, &name, &provider.id)?;
+
+                    if is_ok {
+                        //name.ok(&db);
+                    } else {
+                        //name.delete(&db);
+                    }
+
+                    // TODO UI: add new regsiter name.
+                }
+                ServerEvent::Info(_uname, _ugid, _uaddr, _ubio, _uavatar) => {
+                    // TODO UI: show search result.
+                }
+                ServerEvent::None(_name) => {
+                    // TODO UI: show search result.
                 }
-                ServerEvent::Result(_name, _is_ok) => {}
-                ServerEvent::Info(_uname, _ugid, _uaddr, _ubio, _uavatar) => {}
-                ServerEvent::None(_name) => {}
                 ServerEvent::Response(_ugid, _uname, _is_ok) => {}
             }
         }

src/apps/domain/models.rs

@@ -7,7 +7,7 @@ use tdn_storage::local::{DStorage, DsValue};
 /// Provider Model.
 pub(crate) struct Provider {
     /// db auto-increment id.
-    id: i64,
+    pub id: i64,
     /// name.
     name: String,
     /// address.
@@ -16,11 +16,25 @@ pub(crate) struct Provider {
     is_ok: bool,
     /// is default.
     is_default: bool,
+    /// support request proxy.
+    is_proxy: bool,
     /// is actived.
     is_actived: bool,
 }
 
 impl Provider {
+    pub fn prepare(addr: PeerAddr) -> Self {
+        Self {
+            id: 0,
+            name: addr.to_hex(),
+            addr: addr,
+            is_ok: false,
+            is_default: false,
+            is_proxy: false,
+            is_actived: false,
+        }
+    }
+
     pub fn to_rpc(&self) -> RpcParam {
         json!([
             self.id,
@@ -28,12 +42,15 @@ impl Provider {
             self.addr.to_hex(),
             self.is_ok,
             self.is_default,
+            self.is_proxy,
+            self.is_actived,
         ])
     }
 
     fn from_values(mut v: Vec<DsValue>) -> Self {
         Self {
             is_actived: v.pop().unwrap().as_bool(),
+            is_proxy: 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()),
@@ -44,8 +61,9 @@ impl Provider {
 
     /// 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 matrix = db.query(
+            "SELECT id, name, addr, is_ok, is_default, is_proxy, is_actived FROM providers",
+        )?;
         let mut providers = vec![];
         for values in matrix {
             providers.push(Self::from_values(values));
@@ -56,7 +74,7 @@ impl Provider {
     /// 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 = {}",
+            "SELECT id, name, addr, is_ok, is_default, is_proxy, is_actived FROM providers WHERE id = {}",
             id
         );
         let mut matrix = db.query(&sql)?;
@@ -70,7 +88,7 @@ impl Provider {
     /// 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 = '{}'",
+            "SELECT id, name, addr, is_ok, is_default, is_proxy, is_actived FROM providers WHERE addr = '{}'",
             addr.to_hex()
         );
         let mut matrix = db.query(&sql)?;
@@ -89,22 +107,24 @@ impl Provider {
         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 = {}",
+            let sql = format!("UPDATE providers SET name = '{}', addr = '{}', is_ok = {}, is_default = {}, is_proxy = {}, is_actived = {} WHERE id = {}",
                 self.name,
                 self.addr.to_hex(),
                 self.is_ok,
                 self.is_default,
+                self.is_proxy,
                 self.is_actived,
                 self.id
             );
             db.update(&sql)?;
         } else {
             let sql = format!(
-                "INSERT INTO providers (name, addr, is_ok, is_default, is_actived) VALUES ('{}', '{}', {}, {}, {})",
+                "INSERT INTO providers (name, addr, is_ok, is_default, is_proxy, is_actived) VALUES ('{}', '{}', {}, {}, {}, {})",
                 self.name,
                 self.addr.to_hex(),
                 self.is_ok,
                 self.is_default,
+                self.is_proxy,
                 self.is_actived,
             );
             let id = db.insert(&sql)?;
@@ -113,6 +133,21 @@ impl Provider {
         Ok(())
     }
 
+    pub fn ok(&mut self, db: &DStorage, name: String, is_proxy: bool) -> Result<()> {
+        self.name = name;
+        self.is_proxy = is_proxy;
+        self.is_actived = true;
+        self.is_ok = true;
+
+        let sql = format!("UPDATE providers SET name = '{}', is_ok = true, is_proxy = {}, is_actived = true WHERE id = {}",
+                self.name,
+                self.is_proxy,
+                self.id
+            );
+        db.update(&sql)?;
+        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);
@@ -184,11 +219,11 @@ impl Name {
         Err(anyhow!("name is missing"))
     }
 
-    /// insert a new provider.
-    pub fn get_by_addr(db: &DStorage, addr: &PeerAddr) -> Result<Self> {
+    /// get name register.
+    pub fn get_by_name_provider(db: &DStorage, name: &str, provider: &i64) -> Result<Self> {
         let sql = format!(
-            "SELECT id, name, addr, is_ok, is_default, is_actived FROM providers WHERE addr = '{}'",
-            addr.to_hex()
+            "SELECT id, provider, name, bio, is_ok, is_actived FROM names WHERE name = '{}' AND provider = {}",
+            name, provider
         );
         let mut matrix = db.query(&sql)?;
         if matrix.len() > 0 {

src/apps/domain/rpc.rs

@@ -7,20 +7,39 @@ use tdn::types::{
 
 use domain_types::PeerEvent;
 
-use super::add_layer;
-use crate::rpc::RpcState;
+use super::{
+    add_layer,
+    models::{Name, Provider},
+};
+use crate::{rpc::RpcState, storage::domain_db};
 
 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-list",
+        |gid: GroupId, _params: Vec<RpcParam>, state: Arc<RpcState>| async move {
+            let db = domain_db(state.layer.read().await.base(), &gid)?;
+
+            // list providers.
+            let providers: Vec<RpcParam> =
+                Provider::list(&db)?.iter().map(|p| p.to_rpc()).collect();
+
+            // list names.
+            let names: Vec<RpcParam> = Name::list(&db)?.iter().map(|p| p.to_rpc()).collect();
+
+            Ok(HandleResult::rpc(json!([providers, names])))
+        },
+    );
 
     handler.add_method(
         "domain-provider-add",
-        |gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
+        |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();
+            let db = domain_db(state.layer.read().await.base(), &gid)?;
+            let mut p = Provider::prepare(provider);
+            p.insert(&db);
+
             add_layer(&mut results, provider, PeerEvent::Check, gid)?;
             Ok(results)
         },

src/migrate/domain.rs

@@ -13,5 +13,6 @@ pub(super) const DOMAIN_VERSIONS: [&str; 2] = [
     addr TEXT NOT NULL,
     is_ok INTEGER NOT NULL,
     is_default INTEGER NOT NULL,
+    is_proxy INTEGER NOT NULL,
     is_actived INTEGER NOT NULL);",
 ];