public IEnumerable <ITradeData> ReadTradeData(TextReader textReader)
{
string line = textReader.ReadLine();
var cIdx = ColumnIndexes.GeFromHeaderLine(line, Separator);
int rowNo = 2;
while ((line = textReader.ReadLine()) != null)
{
ITradeData tradeData = null;
try
{
string[] values = line.Split(new char[] { Separator });
if (values.Length > 6)
{
throw new FormatException("Too many columns in a row.");
}
tradeData = new TradeData(values[cIdx.DateIndex], values[cIdx.OpenIndex], values[cIdx.HighIndex], values[cIdx.LowIndex], values[cIdx.CloseIndex], values[cIdx.VolumeIndex]).CheckDataBusinessCorrectness();
}
catch (Exception e)
{
e.Data["rowNo"] = rowNo;
Trace.TraceError("Exception when processing row number: " + rowNo + " (" + e.Message + ")");
throw e;
}
rowNo++;
yield return(tradeData);
}
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var key = Key.Get(context);
var encoding = Encoding.Get(context);
var iterations = Iterations.Get(context);
var inDt = DataTable.Get(context);
var dataColumns = DataTableHelper.IdentifyDataColumns(inDt, ColumnIndexes?.Get(context), ColumnNames?.Get(context));
var outDt = DataTableHelper.NewCryptoDataTable(inDt, dataColumns);
using (var crypto = new Crypto(Algorithm, encoding, iterations))
{
outDt.BeginLoadData();
AddToDataTable(inDt, outDt, dataColumns, key, crypto);
outDt.AcceptChanges();
outDt.EndLoadData();
}
var sortBy = Sort.Get(context);
if (sortBy != null)
{
outDt.DefaultView.Sort = sortBy;
outDt = outDt.DefaultView.ToTable();
}
// Outputs
return((ctx) => Result.Set(ctx, outDt));
}
/// <summary>
/// Gets the stored value in the column specified by name
/// </summary>
/// <typeparam name="T">Target type</typeparam>
/// <param name="name">Name of the column</param>
/// <returns></returns>
public T GetValue <T>(string name)
{
if (!ColumnIndexes.ContainsKey(name))
{
throw new ArgumentException(String.Format("Column {0} not found", name));
}
return(GetValue <T>(ColumnIndexes[name]));
}
/// <summary>
/// Gets the stored value in the column specified by name.
/// </summary>
/// <typeparam name="T">Target type</typeparam>
/// <param name="name">Name of the column</param>
/// <returns></returns>
public virtual T GetValue <T>(string name)
{
//The method is marked virtual to allow to be mocked
if (!ColumnIndexes.ContainsKey(name))
{
throw new ArgumentException(String.Format("Column {0} not found", name));
}
return(GetValue <T>(ColumnIndexes[name]));
}
/// <summary>
/// Gets a column information by name. Returns null if not found.
/// </summary>
public CqlColumn GetColumn(string name)
{
int index;
if (!ColumnIndexes.TryGetValue(name, out index))
{
return(null);
}
return(Columns[index]);
}
public static ColumnIndexes GeFromHeaderLine(string headerLine, char separator)
{
ColumnIndexes indexes = new ColumnIndexes();
var columns = headerLine.Split(new char[] { separator });
indexes.DateIndex = Array.IndexOf <string>(columns, "Date");
indexes.OpenIndex = Array.IndexOf <string>(columns, "Open");
indexes.HighIndex = Array.IndexOf <string>(columns, "High");
indexes.LowIndex = Array.IndexOf <string>(columns, "Low");
indexes.CloseIndex = Array.IndexOf <string>(columns, "Close");
indexes.VolumeIndex = Array.IndexOf <string>(columns, "Volume");
return(indexes);
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
var source = DataTable.Get(context);
var result = new Dictionary <string, object>();
if (source.Rows.Count > 0)
{
var dataColumns = DataTableHelper.IdentifyDataColumns(source, ColumnIndexes?.Get(context), ColumnNames?.Get(context));
var convertibleValues = IdentifyConvertibleValues(source, dataColumns);
Compute(source.AsEnumerable(), result, convertibleValues);
}
// Outputs
return((ctx) => Result.Set(ctx, result));
}
private Func <DataRow, bool> GetCustomModeHandler(AsyncCodeActivityContext context, DataTable dt, Func <object, bool> predicate)
{
var indexes = new HashSet <int>();
var colIndexes = ColumnIndexes.Get(context);
if (colIndexes != null)
{
foreach (var index in colIndexes)
{
indexes.Add(index);
}
}
else
{
var index = 0;
var names = ColumnNames.Get(context);
foreach (DataColumn col in dt.Columns)
{
if (names.Contains(col.ColumnName))
{
indexes.Add(index);
}
index++;
}
}
IEnumerable <object> filter(DataRow dr) => dr.ItemArray.Where((_, index) => indexes.Contains(index));
if (Operator == ConditionOperator.And)
{
return((DataRow dr) => filter(dr).Any(predicate));
}
return((DataRow dr) => filter(dr).All(predicate));
}
internal void CheckCommandsForIndexes()
{
bool isTransposed = false;
foreach (Command command in Commands)
{
if ((command as TransposeCommand) != null)
{
isTransposed = !isTransposed;
}
var indexedCommand = command as IUseIndexes;
if (indexedCommand != null)
{
foreach (Index usedIndex in indexedCommand.UsedIndexes)
{
if (isTransposed)
{
if (!RowIndexes.Any(i => i == usedIndex || i.IsAll))
{
usedIndex.IsHidden = true;
RowIndexes.Add(usedIndex);
}
}
else
{
if (!ColumnIndexes.Any(i => i == usedIndex || i.IsAll))
{
usedIndex.IsHidden = true;
ColumnIndexes.Add(usedIndex);
}
}
}
}
var errorBarCommand = command as ErrorBarCommand;
if (errorBarCommand != null)
{
ColumnIndexes.Add(errorBarCommand.MinusIndex);
if (errorBarCommand.PlusIndex != null)
{
ColumnIndexes.Add(errorBarCommand.PlusIndex);
}
}
var yCommand = command as YCommand;
if (yCommand != null)
{
if (isTransposed)
{
if (!RowIndexes.Any(i => i == yCommand.Index || i.IsAll))
{
RowIndexes.Add(yCommand.Index);
}
}
else
{
if (!ColumnIndexes.Any(i => i == yCommand.Index || i.IsAll))
{
ColumnIndexes.Add(yCommand.Index);
}
}
}
}
}
/// <summary>
/// Gets a column information by name. Returns null if not found.
/// </summary>
public CqlColumn GetColumn(string name)
{
return(ColumnIndexes.TryGetValue(name, out var index)
? Columns[index]
: null);
}
public BoardCellLocation(ColumnIndexes column, RowIndexes row)
{
Column = column;
Row = row;
}
private string GetPhoneNumber(Word.Row row, ColumnIndexes index)
{
string phoneNumber = row.Cells[(int)index].Range.Text;
phoneNumber = RemoveEmptyRowCharacters(phoneNumber);
return Utility.RemoveSpaces(phoneNumber);
}
private ProductIncrementalValue CreateProductIncrementalValue(string row, int noOfRowValues, ColumnIndexes columnIndexes)
{
var rowValues = SplitRow(row);
if (rowValues.Count() != noOfRowValues)
{
InvalidInputRows.Add(row);
return(null);
}
string productName = rowValues[columnIndexes.ProductNameIndex];
int originYear;
if (!int.TryParse(rowValues[columnIndexes.OriginYearIndex], out originYear))
{
InvalidInputRows.Add(row);
return(null);
}
int developmentYear;
if (!int.TryParse(rowValues[columnIndexes.DevelopmentYearIndex], out developmentYear))
{
InvalidInputRows.Add(row);
return(null);
}
double incrementalValue;
if (!double.TryParse(rowValues[columnIndexes.IncrementalValueIndex], out incrementalValue))
{
InvalidInputRows.Add(row);
return(null);
}
if (!ValidateParameters(productName, originYear, developmentYear))
{
InvalidInputRows.Add(row);
return(null);
}
var productIncrementalValue = new ProductIncrementalValue
{
ProductName = productName,
OriginYear = originYear,
DevelopmentYear = developmentYear,
IncrementalValue = incrementalValue
};
return(productIncrementalValue);
}
