Beispiel #1
0
        public void NodesCommand(PromptOutputStyle output = PromptOutputStyle.json)
        {
            var peers = _serverContext.ConnectedPeers;

            switch (output)
            {
            case PromptOutputStyle.json:
            {
                _consoleHandler.WriteObject(
                    new
                    {
                        Count = peers.Count,
                        Nodes = peers
                                .OrderBy(u => u.Value.ConnectionDate)
                                .Select(u => new { Address = u.Key, ConnectedTime = (DateTime.UtcNow - u.Value.ConnectionDate) })
                                .ToArray()
                    }, PromptOutputStyle.json);
                break;
            }

            default:
            {
                _consoleHandler.WriteLine("Connected: " + peers.Count);

                foreach (var peer in peers.OrderBy(u => u.Value.ConnectionDate))
                {
                    _consoleHandler.WriteLine(peer.Key.ToString() + " - " +
                                              // Connected time
                                              (DateTime.UtcNow - peer.Value.ConnectionDate).ToString());
                }
                break;
            }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Write object
        /// </summary>
        /// <param name="obj">Object</param>
        /// <param name="output">Output</param>
        private void WriteObject(object obj, PromptOutputStyle output)
        {
            switch (output)
            {
            case PromptOutputStyle.json:
            {
                _consoleWriter.WriteLine(JsonConvert.SerializeObject(obj, Formatting.Indented));
                break;
            }

            case PromptOutputStyle.raw:
            {
                if (obj is byte[] data)
                {
                    _consoleWriter.WriteLine(data.ToHexString(true));
                }
                else
                {
                    _consoleWriter.WriteLine(_serializer.Serialize(obj).ToHexString(true));
                }

                break;
            }
            }
        }
Beispiel #3
0
        public void WalletListAccountCommand(PromptOutputStyle output = PromptOutputStyle.json)
        {
            _walletManager.CheckWalletIsOpen();
            var currentWallet = _walletManager.Wallet;

            _consoleWriter.WriteObject(currentWallet, output);
        }
        private void BlockCommand(UInt256 blockHash, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var block = Blockchain.GenesisBlock;

            WriteObject(block, output);
        }
        private void AssetCommand(UInt256 hash, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var tx = new Asset();

            WriteObject(tx, output);
        }
        private void ContractCommand(string query, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var tx = new Contract();

            WriteObject(tx, output);
        }
        private void TxCommand(UInt256 hash, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var tx = new Transaction();

            WriteObject(tx, output);
        }
        private void BlockCommand(ulong blockIndex, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var block = Blockchain.GenesisBlock;

            WriteObject(block, output);
        }
        private void HeaderCommand(ulong blockIndex, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var header = new BlockHeader();

            WriteObject(header, output);
        }
        private void HeaderCommand(UInt256 blockHash, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            var header = new BlockHeader();

            WriteObject(header, output);
        }
        private void TxCommand(ulong blockIndex, ushort txNumber, PromptOutputStyle output = PromptOutputStyle.json)
        {
            // TODO: Change this

            //var block = Blockchain.GenesisBlock;
            //var tx = block.Transactions[txNumber];

            var tx = new Transaction();

            WriteObject(tx, output);
        }
 public async Task ContractCommand(UInt160 hash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleWriter.WriteObject(await _blockchain?.GetContract(hash), output);
 }
Beispiel #13
0
        /// <summary>
        /// Write object
        /// </summary>
        /// <param name="obj">Object</param>
        /// <param name="output">Output</param>
        /// <param name="style">Style</param>
        public void WriteObject(object obj, PromptOutputStyle output, ConsoleOutputStyle style = ConsoleOutputStyle.Output)
        {
            if (obj == null)
            {
                WriteLine("NULL", ConsoleOutputStyle.DarkRed);
                return;
            }

            switch (output)
            {
            case PromptOutputStyle.json:
            {
                var settings = new JsonSerializerSettings()
                {
                };

                settings.Converters.Add(new StringEnumConverter());

                using (TextReader tx = new StringReader(obj is JObject ? obj.ToString() : JsonConvert.SerializeObject(obj, settings)))
                    using (JsonTextReader reader = new JsonTextReader(tx))
                    {
                        var indent = "";
                        var last   = JsonToken.None;

                        while (reader.Read())
                        {
                            var first = last == JsonToken.None;

                            switch (reader.TokenType)
                            {
                            case JsonToken.StartArray:
                            {
                                var app = first ? indent : Environment.NewLine + indent;

                                Write(app + "[", ConsoleOutputStyle.DarkGray);
                                indent += " ";
                                break;
                            }

                            case JsonToken.StartConstructor:
                            case JsonToken.StartObject:
                            {
                                var app = first ? indent : Environment.NewLine + indent;

                                Write(app + "{", ConsoleOutputStyle.DarkGray);
                                indent += " ";
                                break;
                            }

                            case JsonToken.EndArray:
                            {
                                indent = indent.Remove(indent.Length - 1, 1);

                                if (last == JsonToken.StartArray)
                                {
                                    Write(" ]", ConsoleOutputStyle.DarkGray);
                                }
                                else
                                {
                                    var app = first ? indent : Environment.NewLine + indent;

                                    Write(app + "]", ConsoleOutputStyle.DarkGray);
                                }
                                break;
                            }

                            case JsonToken.EndConstructor:
                            case JsonToken.EndObject:
                            {
                                indent = indent.Remove(indent.Length - 1, 1);

                                if (last == JsonToken.StartConstructor || last == JsonToken.StartObject)
                                {
                                    Write(" }", ConsoleOutputStyle.DarkGray);
                                }
                                else
                                {
                                    var app = first ? indent : Environment.NewLine + indent;

                                    Write(app + "}", ConsoleOutputStyle.DarkGray);
                                }
                                break;
                            }

                            case JsonToken.PropertyName:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first ? indent : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + ScapeJsonString(reader.Value) + ":", ConsoleOutputStyle.Gray);
                                break;
                            }

                            case JsonToken.String:
                            case JsonToken.Comment:
                            case JsonToken.Date:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first || last == JsonToken.PropertyName ? "" : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + ScapeJsonString(reader.Value), ConsoleOutputStyle.White);
                                break;
                            }

                            case JsonToken.Null:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first || last == JsonToken.PropertyName ? "" : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + "NULL", ConsoleOutputStyle.DarkRed);
                                break;
                            }

                            case JsonToken.Float:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first || last == JsonToken.PropertyName ? "" : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + Convert.ToDecimal(reader.Value).ToString(DoubleFixedPoint), ConsoleOutputStyle.White);
                                break;
                            }

                            case JsonToken.Bytes:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first || last == JsonToken.PropertyName ? "" : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + ((byte[])reader.Value).ToHexString(true), ConsoleOutputStyle.White);
                                break;
                            }

                            case JsonToken.Boolean:
                            case JsonToken.Integer:
                            case JsonToken.Raw:
                            case JsonToken.Undefined:
                            {
                                var needComma = NeedJsonComma(last);
                                var app       = first || last == JsonToken.PropertyName ? "" : Environment.NewLine + indent;
                                if (needComma)
                                {
                                    app = " ," + app;
                                }

                                Write(app + ScapeJsonString(reader.Value), ConsoleOutputStyle.White);
                                break;
                            }
                            }

                            last = reader.TokenType;
                        }

                        WriteLine("", style);
                    }
                break;
            }

            case PromptOutputStyle.raw:
            {
                if (obj is byte[] data)
                {
                    WriteLine(data.ToHexString(true), style);
                }
                else
                {
                    WriteLine(BinarySerializer.Default.Serialize(obj).ToHexString(true));
                }
                break;
            }
            }
        }
        public async Task ContractCommand(string query, EnumerableExtensions.QueryMode mode = EnumerableExtensions.QueryMode.Contains, PromptOutputStyle output = PromptOutputStyle.json)
        {
            var contracts = await _blockchain?.GetContracts();

            var result = contracts.QueryResult(query, mode).ToArray();

            _consoleWriter.WriteObject(result, output);
        }
 public async Task AssetCommand(UInt256 hash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleHandler.WriteObject(await _assetModel.GetAsset(hash), output);
 }
        public async Task TxCommand(uint blockIndex, ushort txNumber, PromptOutputStyle output = PromptOutputStyle.json)
        {
            var block = await _blockRepository.GetBlock(blockIndex);

            _consoleHandler.WriteObject(block.Transactions?[txNumber], output);
        }
 public async Task TxCommand(UInt256 hash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleHandler.WriteObject(await _transactionModel.GetTransaction(hash), output);
 }
 public async Task BlockCommand(UInt256 blockHash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleHandler.WriteObject(await _blockRepository.GetBlock(blockHash), output);
 }
 public async Task BlockCommand(uint blockIndex, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleHandler.WriteObject(await _blockRepository.GetBlock(blockIndex), output);
 }
 public async Task TxCommand(UInt256 hash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleWriter.WriteObject(await _blockchain?.GetTransaction(hash), output);
 }
        public Task ContractCommand(string query, EnumerableExtensions.QueryMode mode = EnumerableExtensions.QueryMode.Contains, PromptOutputStyle output = PromptOutputStyle.json)
        {
            throw new NotImplementedException();
            //var contracts = await _blockchain?.GetContracts();
            //var result = contracts.QueryResult(query, mode).ToArray();

            //_consoleHandler.WriteObject(result, output);
        }
        public async Task AssetCommand(string query, EnumerableExtensions.QueryMode mode = EnumerableExtensions.QueryMode.Contains, PromptOutputStyle output = PromptOutputStyle.json)
        {
            var assets = await _assetModel.GetAssets();

            var result = assets.QueryResult(query, mode).ToArray();

            _consoleHandler.WriteObject(result, output);
        }
 public async Task HeaderCommand(uint blockIndex, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleWriter.WriteObject(await _blockchain?.GetBlockHeader(blockIndex), output);
 }
 public Task ContractCommand(UInt160 hash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     throw new NotImplementedException();
     //_consoleHandler.WriteObject(await _blockchain?.GetContract(hash), output);
 }
 public async Task BlockCommand(UInt256 blockHash, PromptOutputStyle output = PromptOutputStyle.json)
 {
     _consoleWriter.WriteObject(await _blockchain?.GetBlock(blockHash), output);
 }