Beispiel #1
0
        async Task <string> SellStock(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "sell_stock";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pStock", command.stockSymbol);
                cmd.Parameters["@pStock"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pStockAmount", (int)(command.funds));
                cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pServerTime", Unix.TimeStamp.ToString());
                cmd.Parameters["@pServerTime"].Direction = ParameterDirection.Input;
                cmd.Parameters.Add(new MySqlParameter("@success", MySqlDbType.Bit));
                cmd.Parameters["@success"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@message", MySqlDbType.Text));
                cmd.Parameters["@message"].Direction = ParameterDirection.Output;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

                if (!Convert.ToBoolean(cmd.Parameters["@success"].Value))
                {
                    return(Convert.ToString(cmd.Parameters["@message"].Value));
                }
                return(null);
            }
        }
Beispiel #2
0
        async Task <string> SellCommit(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "sell_commit";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.Add(new MySqlParameter("@pServerTime", MySqlDbType.Text));
                cmd.Parameters["@pServerTime"].Direction = ParameterDirection.Input;
                cmd.Parameters.Add(new MySqlParameter("@pStock", MySqlDbType.Text));
                cmd.Parameters["@pStock"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@pStockAmount", MySqlDbType.Int32));
                cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@success", MySqlDbType.Bit));
                cmd.Parameters["@success"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@message", MySqlDbType.Text));
                cmd.Parameters["@message"].Direction = ParameterDirection.Output;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

                if (!Convert.ToBoolean(cmd.Parameters["@success"].Value))
                {
                    return(Convert.ToString(cmd.Parameters["@message"].Value));
                }
                command.funds       = Convert.ToDecimal(cmd.Parameters["@pStockAmount"].Value);
                command.stockSymbol = Convert.ToString(cmd.Parameters["@pStock"].Value);
                return($"Successfully sold ${String.Format("{0:0.00}", command.funds / 100m)} worth of {command.stockSymbol}");
            }
        }
Beispiel #3
0
        async Task <string> BuyCancel(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "buy_cancel_stock";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pServerTime", Unix.TimeStamp);
                cmd.Parameters["@pServerTime"].Direction = ParameterDirection.Input;
                cmd.Parameters.Add(new MySqlParameter("@success", MySqlDbType.Bit));
                cmd.Parameters["@success"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@message", MySqlDbType.Text));
                cmd.Parameters["@message"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@pStock", MySqlDbType.VarChar, 3));
                cmd.Parameters["@pStock"].Direction = ParameterDirection.Output;
                cmd.Parameters.Add(new MySqlParameter("@pStockAmount", MySqlDbType.Int32));
                cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Output;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

                if (!Convert.ToBoolean(cmd.Parameters["@success"].Value))
                {
                    return(LogErrorEvent(command, Convert.ToString(cmd.Parameters["@message"].Value)));
                }
                return($"Successfully cancelled {Convert.ToDecimal(cmd.Parameters["@pStockAmount"].Value) / 100m} worth of {cmd.Parameters["@pStock"].Value}.");
            }
        }
Beispiel #4
0
        async Task <string> CheckUserStock(MySqlCommand cmd, UserCommandType command)
        {
            cmd.CommandText = "get_user_stock";

            cmd.Parameters.AddWithValue("@pUserId", command.username);
            cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
            cmd.Parameters.AddWithValue("@pStock", command.stockSymbol);
            cmd.Parameters["@pStock"].Direction = ParameterDirection.Input;
            cmd.Parameters.Add("@pStockAmount", DbType.Int32);
            cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Output;

            await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

            if (cmd.Parameters["@pStockAmount"].Value == DBNull.Value)
            {
                return(LogErrorEvent(command, "User does not exist or does not have this stock"));
            }
            if (Convert.ToInt32(cmd.Parameters["@pStockAmount"].Value) < command.funds)
            {
                return(LogErrorEvent(command, "Insufficient user stocks"));
            }

            command.fundsSpecified = false;
            return(await SellTriggerTimer.StartOrUpdateTimer(command).ConfigureAwait(false));;
        }
Beispiel #5
0
        public static async Task <string> StartOrUpdateTimer(UserCommandType command)
        {
            BuyTriggerTimer timer;
            bool            newTimer;

            lock (_timerLock)
            {
                newTimer = !_timers.TryGetValue(command.stockSymbol, out timer);

                if (newTimer)
                {
                    if (command.fundsSpecified)
                    {
                        return("Set buy amount before creating trigger");
                    }
                    timer = new BuyTriggerTimer(command.stockSymbol);
                    if (!_timers.TryAdd(command.stockSymbol, timer))
                    {
                        LogDebugEvent(command, "Error adding timer");
                    }
                }
            }

            var msg = await timer.AddOrUpdateUser(command).ConfigureAwait(false);

            if (newTimer)
            {
                var _ = timer.Start();
            }
            return(msg);
        }
Beispiel #6
0
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            string result = "";

            try
            {
                var trigger = SellTriggerTimer.RemoveUserTrigger(command.username, command.stockSymbol);
                if (trigger != null)
                {
                    command.fundsSpecified = true;
                    command.funds          = trigger.Amount;
                    // Check if trigger exists
                    MySQL db = new MySQL();
                    result = await db.PerformTransaction(CancelSell, command).ConfigureAwait(false);
                }
                else
                {
                    return(LogErrorEvent(command, $"No trigger set for {command.stockSymbol}"));
                }
            }
            catch (Exception ex)
            {
                LogDebugEvent(command, ex.Message);
                return(LogErrorEvent(command, "Error processing command"));
            }
            return(result);
        }
Beispiel #7
0
        // ExecuteClient() Method
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            if (!command.fundsSpecified || command.funds <= 0)
            {
                return("Invalid funds specified.");
            }

            string result;

            try
            {
                MySQL db = new MySQL();

                await db.PerformTransaction(AddMoney, command).ConfigureAwait(false);

                result = $"Successfully added ${String.Format("{0:0.00}", command.funds / 100m)} into {command.username}'s account";

                LogTransactionEvent(command, "add");
            }
            catch (Exception e)
            {
                LogDebugEvent(command, e.Message);
                result = LogErrorEvent(command, "Error occurred adding money.");
            }
            return(result);
        }
Beispiel #8
0
        async Task <string> GetStock(UserCommandType command)
        {
            var delay = 500;

            try
            {
                string result = null;
                do
                {
                    ConnectedServices cs   = clientConnections.GetOrAdd(command.username, new ConnectedServices());
                    ServiceConnection conn = await cs.GetServiceConnectionAsync(Service.QUOTE_SERVICE).ConfigureAwait(false);

                    if (conn == null)
                    {
                        throw new Exception("Failed to connect to service");
                    }
                    result = await conn.SendAsync(command, true).ConfigureAwait(false);

                    if (result == null)
                    {
                        await Task.Delay(delay).ConfigureAwait(false); // Short delay before tring again
                    }
                } while (result == null);

                return(result);
            }
            catch (Exception ex)
            {
                LogDebugEvent(command, ex.Message);
                return(null);
            }
        }
Beispiel #9
0
        async Task <string> GetQuote(UserCommandType command)
        {
            ServiceConnection conn = new ServiceConnection(Server.QUOTE_SERVER);
            var quote = await conn.Send($"{command.stockSymbol},{command.username}", true).ConfigureAwait(false);

            var cost = LogQuoteServerEvent(command, quote);

            var result = $"{cost},{Unix.TimeStamp}";

            //redisConn.StringSet(command.stockSymbol.ToUpper(), result);
            return(result);
        }
        public override int ReadFrom(byte[] Buffer, int StartIndex = 0)
        {
            int cursor = StartIndex;

            commandType = (UserCommandType)Buffer[cursor];
            cursor++;                                               // Type     (1 byte)

            Array.Copy(Buffer, cursor, Data, 0, Data.Length);
            cursor += Data.Length;

            return cursor - StartIndex;
        }
Beispiel #11
0
        public override int ReadFrom(byte[] Buffer, int StartIndex = 0)
        {
            int cursor = StartIndex;

            commandType = (UserCommandType)Buffer[cursor];
            cursor++;                                               // Type     (1 byte)

            Array.Copy(Buffer, cursor, Data, 0, Data.Length);
            cursor += Data.Length;

            return(cursor - StartIndex);
        }
Beispiel #12
0
        async Task <string> SetUserMoney(MySqlCommand cmd, UserCommandType command)
        {
            cmd.CommandText = "hold_user_money";

            cmd.Parameters.AddWithValue("@pUserId", command.username);
            cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
            cmd.Parameters.AddWithValue("@pMoney", (int)command.funds);
            cmd.Parameters["@pMoney"].Direction = ParameterDirection.Input;

            await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

            return(null);
        }
Beispiel #13
0
        void LogDebugEvent(UserCommandType command, string err)
        {
            DebugType bug = new DebugType()
            {
                timestamp      = Unix.TimeStamp.ToString(),
                server         = Server.WEB_SERVER.Abbr,
                transactionNum = command.transactionNum,
                command        = command.command,
                debugMessage   = err
            };

            _writer.WriteRecord(bug);
        }
        public async Task HandleMessage(TGMessageDTO dto, User user, Message message)
        {
            var chatType = dto.Chat.GetChatType();

            if (chatType != ChatType.Private)
            {
                if (dto.Text.ToUpper().Contains(ApplicationDefaults.CNBotUserName))
                {
                    // Only use command in private chat
                    await _telegramHttpClient.SendMessage(TGSendMessageDTO.BuildOnlyUseInPrivateMessage(dto.Chat.Id, dto.MessageId));
                }
                //If not my command. Nothing to do
                return;
            }
            var             utcNow      = DateTime.UtcNow;
            UserCommandType commandType = dto.GetCommandType();

            if (commandType == UserCommandType.None)
            {
                var lastCommand = await _userService.FindLastCommand(user.Id);

                if (lastCommand == null || lastCommand.Completed)
                {
                    // No command found. So we just show the default message
                    await _telegramHttpClient.SendMessage(TGSendMessageDTO.BuildUnrecognizedMessage(dto.Chat.Id, dto.MessageId));

                    return;
                }
                else
                {
                    commandType = lastCommand.Type;
                }
            }
            var command = new UserCommand
            {
                Created   = utcNow,
                Completed = false,
                Type      = commandType,
                UserId    = user.Id,
                Text      = dto.Text
            };
            await _userService.AddCommand(command);

            await this.HandleCommand(dto, command, message);

            if (command.Type != UserCommandType.Remove && dto.Entities != null && dto.Entities.Any())
            {
                _eventBus.Publish(new TelegramMessageEntityExtractEvent(dto.Entities));
            }
        }
Beispiel #15
0
        public bool Validate(string[] args, ref UserCommandType command, out string error)
        {
            if (args.Length != _argLength)
            {
                error = _usage;
                return(false);
            }
            if (_usernameIndex > 0)
            {
                command.username = args[_usernameIndex].Trim();
                if (string.IsNullOrEmpty(command.username))
                {
                    error = "Invalid username";
                    return(false);
                }
            }
            if (_filenameIndex > 0)
            {
                command.filename = args[_filenameIndex].Trim();
                if (string.IsNullOrEmpty(command.filename))
                {
                    error = "Invalid username";
                    return(false);
                }
            }
            if (_fundsIndex > 0)
            {
                if (!Decimal.TryParse(args[_fundsIndex], out decimal funds) || funds < 0)
                {
                    error = "Invalid amount specified";
                    return(false);
                }
                command.fundsSpecified = true;
                command.funds          = funds * 100;
            }
            if (_stockIndex > 0)
            {
                command.stockSymbol = args[_stockIndex];
                if (command.stockSymbol.Length > 3 || command.stockSymbol.Length < 1 ||
                    !System.Text.RegularExpressions.Regex.IsMatch(command.stockSymbol, @"^[a-zA-Z]+$"))
                {
                    error = "Stock symbol is invalid";
                    return(false);
                }
            }

            error = null;
            return(true);
        }
Beispiel #16
0
        static async Task <string> HoldUserStock(MySqlCommand cmd, UserCommandType command)
        {
            cmd.CommandText = "hold_user_stock";

            cmd.Parameters.AddWithValue("@pUserId", command.username);
            cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
            cmd.Parameters.AddWithValue("@pStock", command.stockSymbol);
            cmd.Parameters["@pStock"].Direction = ParameterDirection.Input;
            cmd.Parameters.AddWithValue("@pStockAmount", (int)command.funds);
            cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Input;

            await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

            return(null);
        }
Beispiel #17
0
        private async Task AddMoney(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "add_user";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pFunds", command.funds);
                cmd.Parameters["@pFunds"].Direction = ParameterDirection.Input;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
            }
        }
Beispiel #18
0
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            string result;

            try
            {
                MySQL db = new MySQL();
                result = await db.PerformTransaction(BuyCancel, command).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                result = LogErrorEvent(command, "Error getting account details");
                LogDebugEvent(command, e.Message);
            }
            return(result);
        }
Beispiel #19
0
        protected void LogTransactionEvent(UserCommandType command, string action)
        {
            AccountTransactionType transaction = new AccountTransactionType()
            {
                timestamp      = Unix.TimeStamp.ToString(),
                server         = ServiceDetails.Abbr,
                transactionNum = command.transactionNum,
                action         = action,
                username       = command.username
            };

            if (command.fundsSpecified)
            {
                transaction.funds = command.funds / 100m;
            }
            Auditor.WriteRecord(transaction);
        }
Beispiel #20
0
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            string result = "";

            try
            {
                // Check user account for cash, notify if insufficient funds
                MySQL db = new MySQL();
                result = await db.PerformTransaction(SetAmount, command).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                LogDebugEvent(command, ex.Message);
                return(LogErrorEvent(command, "Error processing command"));
            }
            return(result);
        }
Beispiel #21
0
        async Task <string> SetAmount(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                var msg = await CheckUserStock(cmd, command).ConfigureAwait(false);

                if (msg != null)
                {
                    return(LogErrorEvent(command, msg));
                }
                cmd.Parameters.Clear();
                await HoldUserStock(cmd, command).ConfigureAwait(false);
            }
            LogTransactionEvent(command, "remove");
            return($"Sell amount set successfully for stock {command.stockSymbol}");
        }
Beispiel #22
0
        protected void LogDebugEvent(UserCommandType command, string err)
        {
            DebugType bug = new DebugType()
            {
                timestamp      = Unix.TimeStamp.ToString(),
                server         = ServiceDetails.Abbr,
                transactionNum = command.transactionNum,
                command        = command.command,
                debugMessage   = err,
                fundsSpecified = command.fundsSpecified
            };

            if (command.fundsSpecified)
            {
                bug.funds = command.funds / 100m;
            }
            Auditor.WriteRecord(bug);
        }
Beispiel #23
0
        async Task <string> CancelBuy(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "return_user_money";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pMoney", command.funds);
                cmd.Parameters["@pMoney"].Direction = ParameterDirection.Input;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

                LogTransactionEvent(command, "add");
                return($"Successfully removed trigger to buy stock {command.stockSymbol}");
            }
        }
Beispiel #24
0
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            try
            {
                command.fundsSpecified = true;
                var msg = await SellTriggerTimer.StartOrUpdateTimer(command).ConfigureAwait(false);

                if (msg == null)
                {
                    return($"Trigger amount set successfully for stock {command.stockSymbol}");
                }
                return(LogErrorEvent(command, msg));
            }
            catch (Exception ex)
            {
                LogDebugEvent(command, ex.Message);
                return(LogErrorEvent(command, "Error processing command."));
            }
        }
Beispiel #25
0
        int LogQuoteServerEvent(UserCommandType command, string quote)
        {
            //Cost,StockSymbol,UserId,Timestamp,CryptoKey
            string[]        args       = quote.Split(",");
            QuoteServerType stockQuote = new QuoteServerType()
            {
                username        = args[2],
                server          = Server.QUOTE_SERVER.Abbr,
                price           = Convert.ToDecimal(args[0]),
                transactionNum  = command.transactionNum,
                stockSymbol     = args[1],
                timestamp       = Unix.TimeStamp.ToString(),
                quoteServerTime = args[3],
                cryptokey       = args[4]
            };

            Auditor.WriteRecord(stockQuote);
            return((int)(stockQuote.price * 100));
        }
Beispiel #26
0
        async Task <string> CancelSell(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "return_user_stock";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pStock", command.stockSymbol);
                cmd.Parameters["@pStock"].Direction = ParameterDirection.Input;
                cmd.Parameters.AddWithValue("@pStockAmount", command.funds);
                cmd.Parameters["@pStockAmount"].Direction = ParameterDirection.Input;

                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);

                return($"Successfully removed trigger to sell stock {command.stockSymbol}");
            }
        }
Beispiel #27
0
        /*
         * Logs interserver communication
         * @param command The user command that is driving the process
         */
        protected void LogServerEvent(UserCommandType command)
        {
            SystemEventType sysEvent = new SystemEventType()
            {
                timestamp      = Unix.TimeStamp.ToString(),
                server         = ServiceDetails.Abbr,
                transactionNum = command.transactionNum,
                username       = command.username,
                fundsSpecified = command.fundsSpecified,
                command        = command.command,
                filename       = command.filename,
                stockSymbol    = command.stockSymbol
            };

            if (command.fundsSpecified)
            {
                sysEvent.funds = command.funds / 100m;
            }
            Auditor.WriteRecord(sysEvent);
        }
Beispiel #28
0
        protected override async Task <string> DataReceived(UserCommandType command)
        {
            try
            {
                //IDatabase redisConn = Muxer.GetDatabase(1);
                var result = await _quoteCache.GetOrCreate(command.stockSymbol,
                                                           () => GetQuote(command),
                                                           v => (Unix.TimeStamp - Convert.ToInt64(v.Split(",")[1])) < 60000);

                if (command.command != commandType.SET_BUY_TRIGGER && command.command != commandType.SET_SELL_TRIGGER)
                {
                    return(result.Split(",")[0]);
                }
                return(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                return($"Error getting quote");
            }
        }
Beispiel #29
0
        async Task <string> DisplaySummary(MySqlConnection cnn, UserCommandType command)
        {
            using (MySqlCommand cmd = new MySqlCommand())
            {
                cmd.Connection  = cnn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "display_summary";

                cmd.Parameters.AddWithValue("@pUserId", command.username);
                cmd.Parameters["@pUserId"].Direction = ParameterDirection.Input;
                cmd.Parameters.Add(new MySqlParameter("@pMoney", MySqlDbType.Int32));
                cmd.Parameters["@pMoney"].Direction = ParameterDirection.Output;

                var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false);

                StringBuilder stocks = new StringBuilder();
                try
                {
                    while (await reader.ReadAsync())
                    {
                        // Reads in stock and amount

                        stocks.Append($"{reader.GetString(0)}&nbsp&nbsp&nbsp&nbsp${String.Format("{0:0.00}", Convert.ToDecimal(reader.GetValue(1)) / 100m)}<br>");
                    }
                }
                finally
                {
                    await reader.CloseAsync();
                }

                var money = Convert.ToDecimal(cmd.Parameters["@pMoney"].Value);
                if (money == -1)
                {
                    return("User does not exist");
                }

                return($"User {command.username} has ${String.Format("{0:0.00}", money / 100m)}<br>Stock&nbsp&nbsp&nbsp&nbspAmount<br>" + stocks.ToString());
            }
        }
Beispiel #30
0
        async Task <string> GetStock(string username, string stockSymbol)
        {
            var             delay = 500;
            UserCommandType cmd   = new UserCommandType
            {
                server      = Service.SELL_TRIGGER_SET_SERVICE.Abbr,
                command     = commandType.SET_BUY_TRIGGER,
                stockSymbol = stockSymbol,
                username    = username
            };

            try
            {
                string result = null;
                do
                {
                    ConnectedServices cs   = clientConnections.GetOrAdd(_stockSymbol, new ConnectedServices());
                    ServiceConnection conn = await cs.GetServiceConnectionAsync(Service.QUOTE_SERVICE).ConfigureAwait(false);

                    if (conn == null)
                    {
                        throw new Exception("Failed to connect to service");
                    }
                    result = await conn.SendAsync(cmd, true).ConfigureAwait(false);

                    if (result == null)
                    {
                        await Task.Delay(delay).ConfigureAwait(false); // Short delay before tring again
                    }
                } while (result == null);

                return(result);
            }
            catch (Exception ex)
            {
                LogDebugEvent(cmd, ex.Message);
                return(null);
            }
        }
Beispiel #31
0
        static void LogDebugEvent(UserCommandType command, string err)
        {
            DebugType bug = new DebugType()
            {
                timestamp    = Unix.TimeStamp.ToString(),
                server       = "BTSVC",
                debugMessage = err
            };

            if (command != null)
            {
                bug.transactionNum = command.transactionNum;
                bug.command        = command.command;
                bug.fundsSpecified = command.fundsSpecified;

                if (command.fundsSpecified)
                {
                    bug.funds = command.funds / 100m;
                }
            }
            _auditWriter.WriteRecord(bug);
        }
Beispiel #32
0
 public UserCommandEventArgs(UserCommandType userCommand)
 {
     this.userCommand = userCommand;
 }
 public UserCommandGeneric(UserCommandType CommandType, byte[] Data)
 {
     this.commandType = CommandType;
     this.Data = Data;           
 }