public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText(GetSql());
command.AddOutputParameter("@param", DbType.StringFixedLength, 4);
return(true);
}
public static IDataInteraction AddTableValuedParameter <T>(this IDataInteraction interaction, string name, string typeName, IEnumerable <T> rows)
{
Argument.NotNull(rows, nameof(rows));
var dataTable = new DataTable();
var mappableProperties = typeof(T)
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.PropertyType.IsSupportedPrimitiveType());
var mappers = new List <Action <T, DataRow> >();
foreach (var property in mappableProperties)
{
var p = property;
dataTable.Columns.Add(p.Name, p.PropertyType);
mappers.Add((t, row) => row[p.Name] = p.GetValue(t));
}
foreach (var item in rows)
{
var row = dataTable.NewRow();
foreach (var mapper in mappers)
{
mapper(item, row);
}
dataTable.Rows.Add(row);
}
return(AddTableValuedParameter(interaction, name, typeName, dataTable));
}
public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText(GetSql());
command.AddParameterWithValue("@documentId", _documentId);
command.AddParameterWithValue("@start", _start);
command.AddParameterWithValue("@pageSize", _pageSize);
return(true);
}
public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText(@"
SELECT @value = 'param';
SELECT 'result';");
command.AddOutputParameter("@value", DbType.AnsiString, 5);
return(true);
}
public void Subscribe(IDataInteraction <Data> dataWriter, DirectoryInfo directory, Process process, bool cpuBoxStatus, bool memoryBoxStatus)
{
{
CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken cancelationToken = cts.Token;
ListenedProcesses.Add(process, cts);
Action subscribe = () =>
{
PerformanceCounter ramCounter = new PerformanceCounter("Process", "Working set", process.ProcessName);
PerformanceCounter cpuCounter = new PerformanceCounter("Process", "% Processor Time", process.ProcessName);
List <Data> dataSet = new List <Data>();
while (!cancelationToken.IsCancellationRequested)
{
currentTime = DateTime.Now;
if (cpuBoxStatus)
{
processCpu = (int)cpuCounter.NextValue();
totalCpu = (int)totalCpuCounter.NextValue();
}
else
{
processCpu = (int)cpuCounter.NextValue();
totalCpu = (int)totalCpuCounter.NextValue();
}
if (memoryBoxStatus)
{
processMemory = (int)(ramCounter.NextValue() / 1000000);
totalMemory = (int)totalRamCounter.NextValue();
}
else
{
processMemory = 0;
totalMemory = 0;
}
string time = currentTime.ToString("MM/dd/yyyy HH:mm:ss");
bool notRespond = false;
if (!process.Responding)
{
notRespond = true;
}
currentSize = directory.EnumerateFiles().Sum(file => file.Length);
sizeIncrease = currentSize - previousSize;
line = $"{time},{processCpu},{totalCpu},{processMemory},{totalMemory},{sizeIncrease},{notRespond}";
data = new Data(line);
dataSet.Add(data);
dataWriter.WriteData(dataSet);;
previousSize = currentSize;
Thread.Sleep(1000);
}
};
subs = Task.Factory.StartNew(subscribe, cancelationToken);
};
}
private void DrawingOnce(IDataInteraction <Data> reader)
{
Action _drawing = () =>
{
data = reader.ReadData();
UpdateFormOnce();
Thread.Sleep(1000);
};
drawing = Task.Factory.StartNew(_drawing);
}
public Program
(IDataInteraction dataInteraction,
ISimulation simulation,
IOutputProvider outputProvider,
IContextProvider contextProvider,
ILogger logger)
{
this.dataInteraction = dataInteraction;
this.simulation = simulation;
this.outputProvider = outputProvider;
this.contextProvider = contextProvider;
this.dataInteraction = dataInteraction;
this.logger = logger;
}
public static IDataInteraction AddTableValuedParameter(this IDataInteraction interaction, string name, string typeName, DataTable dataTable)
{
Argument.NotNullOrEmpty(name, nameof(name));
Argument.NotNullOrEmpty(typeName, nameof(typeName));
Argument.NotNull(dataTable, nameof(dataTable));
return(interaction.AddParameter(param =>
{
param.Direction = ParameterDirection.Input;
param.ParameterName = name;
if (param is SqlParameter sqlParameter)
{
sqlParameter.TypeName = typeName;
}
param.Value = dataTable;
}));
}
public static void SetTimeout(this IDataInteraction interaction, TimeSpan timeSpan)
{
Argument.NotNull(interaction, nameof(interaction));
interaction.Command.CommandTimeout = (int)timeSpan.TotalSeconds;
}
public static void SetTimeoutSeconds(this IDataInteraction interaction, int seconds)
{
Argument.NotNull(interaction, nameof(interaction));
interaction.Command.CommandTimeout = seconds;
}
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText("SELECT @value = 5;");
interaction.AddOutputParameter("@value", DbType.Int32, 0);
return(true);
}
public void UpdateDatabase(IDataInteraction dataProvider, IOutputProvider outputProvider, ILogger logger, int sellerId, int buyerId, int shareId, decimal sharePrice, int purchaseQuantity)
{
try
{
if (sellerId == 0 || buyerId == 0 || shareId == 0 || sharePrice == 0 || purchaseQuantity == 0)
{
logger.Write("Incorrect data from randomizer");
throw new Exception("Incorrect data from randomizer");
}
var sellerToChange = dataProvider.GetTrader(sellerId);
if (sellerToChange != null)
{
sellerToChange.Balance += sharePrice * purchaseQuantity;
}
var buyerToChange = dataProvider.GetTrader(buyerId);
if (buyerToChange != null)
{
buyerToChange.Balance -= sharePrice * purchaseQuantity;
}
var sellerShareRecordToChange = dataProvider.GetPortfolio(sellerId, shareId);
if (sellerShareRecordToChange != null)
{
sellerShareRecordToChange.Quantity -= purchaseQuantity;
if (sellerShareRecordToChange.Quantity == 0)
{
#if DEBUG
outputProvider.WriteLine("Removed share record with 0 quantity");
#endif
logger.Write("Removed share record with 0 quantity");
dataProvider.RemovePortfolio(sellerShareRecordToChange);
}
}
if (dataProvider.GetPortfoliosCount(buyerId, shareId) > 0)
{
var buyerShareRecordToChange = dataProvider.GetPortfolio(buyerId, shareId);
if (buyerShareRecordToChange != null)
{
buyerShareRecordToChange.Quantity += purchaseQuantity;
}
}
else
{
#if DEBUG
outputProvider.WriteLine("Add new record to portfolio");
#endif
logger.Write("Add new record to portfolio");
dataProvider.AddPortfolio(buyerId, shareId, purchaseQuantity);
}
var transaction = dataProvider.AddTransaction(buyerId, sellerId, shareId, sharePrice, purchaseQuantity);
dataProvider.SaveChanges();
string message = "Buyer = " + transaction.BuyerId + " Seller = " + transaction.SellerId + " Share name = " + transaction.ShareId +
" Quantity = " + transaction.Quantity + " Price per share = " + transaction.PricePerShare +
" Transaction total = " + transaction.PricePerShare * transaction.Quantity + " Timestamp = " + transaction.DateTime;
outputProvider.WriteLine(message);
logger.Write(message);
}
catch (Exception e)
{
outputProvider.WriteLine(e.Message);
logger.Write(e.Message);
}
}
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText(_simple.GetSql());
return(interaction.IsValid);
}
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText("SELECT @value = 'TEST';");
interaction.AddOutputParameter("@value", DbType.AnsiString, 8000);
return(true);
}
public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText("SELECT @param = 'TEST';");
command.AddOutputParameter("@param", DbType.StringFixedLength, 4);
return(false);
}
public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText("SELECT 'TEST';");
return(false);
}
public bool SetupCommand(IDataInteraction interaction) => _query.SetupCommand(interaction);
public bool SetupCommand(IDataInteraction command)
{
command.ExecuteText("SELECT @param = 'TEST';");
command.AddOutputParameter("@param", DbType.AnsiString, 4);
return(true);
}
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText("SELECT 'TEST'");
return(interaction.IsValid);
}
public bool SetupCommand(IDataInteraction interaction) => _setup(interaction);
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText("SELECT @Value1 AS Value1, @Value2 AS Value2, @Value3 AS Value3;");
interaction.AddParametersWithValues(_values);
return(interaction.IsValid);
}
public bool SetupCommand(IDataInteraction interaction)
{
interaction.ExecuteText("SELECT 1 UNION SELECT 2 UNION SELECT 3");
return(interaction.IsValid);
}
PerformRandomOperation(IDataInteraction dataProvider, IOutputProvider outputProvider, ILogger logger)
{
int sellerId;
int buyerId;
int shareId;
decimal sharePrice;
int purchaseQuantity;
try
{
int numberOfTraders = dataProvider.GetNumberOfTraders();
if (numberOfTraders > 1)
{
List <int> availableSellers = dataProvider.GetAvailableSellers();
if (availableSellers.Count > 0)
{
sellerId = availableSellers[new Random().Next(0, availableSellers.Count)];
}
else
{
throw new Exception("No traders with shares");
}
buyerId = new Random().Next(1, numberOfTraders + 1);
while (sellerId == buyerId)
{
buyerId = new Random().Next(1, numberOfTraders + 1);
}
if (buyerId == sellerId)
{
throw new Exception("buyerId == sellerId");
}
}
else
{
throw new Exception("Not enough traders for a transaction");
}
List <int> availableShares = dataProvider.GetAvailableShares(sellerId);
#if DEBUG
outputProvider.WriteLine("Available shares types = " + availableShares.Count);
#endif
logger.Write("Available shares types = " + availableShares.Count);
shareId = availableShares[new Random().Next(0, availableShares.Count)];
sharePrice = dataProvider.GetSharePrice(shareId);
purchaseQuantity = new Random().Next(1, dataProvider.GetShareQuantityFromPortfoio(sellerId, shareId) + 1);
return(sellerId, buyerId, shareId, sharePrice, purchaseQuantity);
//UpdateDatabase(dataProvider, outputProvider, logger, sellerId, buyerId, shareId, sharePrice, purchaseQuantity);
}
catch (Exception e)
{
outputProvider.WriteLine(e.Message);
logger.Write(e.Message);
}
return(0, 0, 0, 0M, 0);
}
