public MainViewModel()
{
data = new DataReaderWriter(this);
ToDoList = new ObservableCollection <ToDo>(data.LoadToDos());
AddToDoCommand = new AddToDoCommand(this);
DeleteToDoCommand = new DeleteToDoCommand(this);
}
public void RetrieveNames_NonExistingFile_ReturnsListofStrings()
{
var loggerMock = new Mock <ILoggerService>();
var namesRepository = new DataReaderWriter(loggerMock.Object);
string path = Directory.GetCurrentDirectory();
namesRepository.DataSource = @".\..\..\..\DataSource\notExisting.txt";
var unsortedNames = namesRepository.RetrieveNames();
}
public void NewToDoId_ReturnsProperId()
{
var testList = new List <ToDo>();
for (int i = 0; i < 5; i++)
{
testList.Add(new ToDo(i, "test", false, null));
Assert.AreEqual(DataReaderWriter.NewToDoId(testList), testList.Count);
}
}
public void RetrieveNames_ValidTextFile_ReturnsListofStrings()
{
var loggerMock = new Mock <ILoggerService>();
var namesRepository = new DataReaderWriter(loggerMock.Object);
string path = Directory.GetCurrentDirectory();
namesRepository.DataSource = @".\..\..\..\DataSource\unsorted-names-list.txt";
var unsortedNames = namesRepository.RetrieveNames();
Assert.IsTrue(unsortedNames.Count == 11);
}
public void SaveNames_ValidListOfStrings_SavesStringsToFile()
{
var loggerMock = new Mock <ILoggerService>();
var namesRepository = new DataReaderWriter(loggerMock.Object);
List <string> names = new List <string>
{
"Adonis Julius Archer",
"Janet Parsons",
"Vaughn Lewis"
};
namesRepository.Destination = @".\..\..\..\Output";
namesRepository.SaveNames(names);
}
private void toolStripButtonShowEntryData_Click(object sender, EventArgs e)
{
if (listViewProviderEntries.SelectedItems.Count == 0)
{
return;
}
if (listViewProviderEntries.SelectedItems.Count > 1)
{
MessageBox.Show("Select only one entry to show its data.", "Note", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
DataStoreEntry entry = (DataStoreEntry)listViewProviderEntries.SelectedItems[0].Tag;
if (entry.Period.HasValue == false || entry.DataType != DataStoreEntry.EntryDataTypeEnum.DataBar)
{
return;
}
DataReaderWriter <DataBar> readerWriter = entry.GetDataBarReaderWriter();
if (readerWriter == null)
{
MessageBox.Show("Failed to read entry file.", "Open Forex Platform", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
List <DataBar> barData = readerWriter.Read();
RawDataTradeChartSeries series = new RawDataTradeChartSeries(entry.Symbol.Name);
series.Initialize(barData, entry.Period.Value);
ChartForm form = new ChartForm("Entry [" + entry.Symbol.Name + "," + entry.Period.ToString() + "] Data");
form.Chart.MasterPane.Add(series);
form.Chart.MasterPane.FitDrawingSpaceToScreen(true, true);
form.Show(this.ParentForm);
}
/// <summary>
///
/// </summary>
/// <param name="dataDelivery"></param>
/// <returns></returns>
public bool AddData(ReadOnlyCollection <DataTick> data)
{
if (DataType != EntryDataTypeEnum.DataTick)
{// Wrong dataDelivery type for entry.
return(false);
}
if (_quoteCount != 0)
{// Entry already has dataDelivery, TODO: append dataDelivery mode.
return(false);
}
DataReaderWriter <DataTick> readerWriter = GetDataTickReaderWriter();
bool result = readerWriter.Write(data);
if (result && EntryUpdatedEvent != null)
{
EntryUpdatedEvent(this);
}
return(result);
}
internal void ReadPayload(DataReaderWriter reader, int count)
{
var remaining = count;
while (remaining > 0)
{
this.readPayload.WaitForWriteSpace(remaining);
var actual = Math.Min(remaining, this.readPayload.AvailableWrite);
reader(this.readPayload.Data, this.readPayload.WriteOffset, actual);
this.readPayload.Write(actual);
remaining -= actual;
}
lock (this.pendingReads) {
this.pendingReads.Enqueue(count);
this.pendingReadsSemaphore.Release();
}
}
public void AddToDo()
{
ToDoList.Add(new ToDo(DataReaderWriter.NewToDoId(ToDoList.ToList()), NewLabel, false, this));
SaveToDos();
NewLabel = string.Empty;
}
/// <summary>
/// Loads the data entry from a file.
/// </summary>
/// <param name="FileNameGuidSeparator">Separator symbol separating the Guid part from the symbol part. Pass null/string.Empty if none.</param>
public bool LoadFromFile(string filePath, string fileNameGuidSeparator)
{
_fileName = Path.GetFileName(filePath);
_period = null;
_copyright = string.Empty;
string symbolName = Path.GetFileNameWithoutExtension(filePath);
if (string.IsNullOrEmpty(fileNameGuidSeparator) == false)
{
symbolName = symbolName.Substring(0, symbolName.IndexOf(fileNameGuidSeparator));
}
if (FinancialHelper.EstablishForexPairAndPeriod(symbolName, out symbolName) == false)
{
SystemMonitor.OperationWarning(string.Format("Failed to establish symbol information for file [{0}].", filePath));
}
if (DataType == EntryDataTypeEnum.DataBar)
{
DataReaderWriter <DataBar> readerWriter = GetDataBarReaderWriter();
if (readerWriter == null)
{
SystemMonitor.OperationWarning(string.Format("Failed to create reader/writer for file [{0}].", filePath));
_fileName = null;
return(false);
}
_decimalDigits = -1;
readerWriter.DataPageReadEvent += delegate(DataReaderWriter <DataBar> reader, List <DataBar> pageData)
{
if (_period.HasValue == false)
{
_period = FinancialHelper.GetPrevalentPeriod(pageData);
}
if (pageData.Count > 0 && (pageData[0].DateTime < _startTime || _startTime == DateTime.MinValue))
{
_startTime = pageData[0].DateTime;
}
if (pageData.Count > 0 && (pageData[pageData.Count - 1].DateTime > _endTime || _endTime == DateTime.MinValue))
{
_endTime = pageData[pageData.Count - 1].DateTime;
}
if (_decimalDigits < 0)
{
_decimalDigits = FinancialHelper.EstablishDecimalDigits(pageData);
}
return(true);
};
int totalRowsRead = 0;
if (readerWriter.ReadDataPaged(int.MaxValue, out totalRowsRead) == false)
{
_quoteCount = 0;
_symbol = Symbol.Empty;
return(false);
}
_quoteCount = totalRowsRead;
if (readerWriter is HSTDataBarReaderWriter)
{// If this is an Hst, read the additional information from it.
_copyright = ((HSTDataBarReaderWriter)readerWriter).Copyright;
symbolName = ((HSTDataBarReaderWriter)readerWriter).Symbol;
_decimalDigits = ((HSTDataBarReaderWriter)readerWriter).DecimalDigits;
_period = ((HSTDataBarReaderWriter)readerWriter).Period;
}
_symbol = new Symbol(string.Empty, symbolName, FileName.Replace(DataStore.FileNameGuidSeparator, " "));
}
else
{
SystemMonitor.NotImplementedCritical("Mode not supported.");
}
return(true);
}
internal void WritePayload(DataReaderWriter reader) => reader(this.writePayload, this.writePayloadOffset, this.writePayloadLength);
internal void WriteHeader(DataReaderWriter reader) => reader(this.writeHeader.Data, 0, this.writeHeaderLength);
/// <summary>
/// Request bar dataDelivery from entry.
/// </summary>
public bool RequestDataHistoryUpdate(DataSessionInfo sessionInfo, DataHistoryRequest request, bool waitResult)
{
DataStoreEntry entry = DataStore.Instance.GetEntryBySessionInfo(sessionInfo);
if (this.OperationalState != OperationalStateEnum.Operational ||
entry == null)
{
SystemMonitor.OperationError("Data history request received while not operational, or invalid session requrested.");
return(false);
}
if (entry.Period != request.Period)
{
SystemMonitor.OperationError("Data history request received but period not recognized.");
return(false);
}
if (request.MaxValuesRetrieved.HasValue == false)
{
request.MaxValuesRetrieved = int.MaxValue;
}
if (request.StartIndex.HasValue == false)
{
request.StartIndex = -1;
}
GeneralHelper.GenericReturnDelegate <bool> operationDelegate = delegate()
{
if (request.IsTickBased)
{
DataReaderWriter <DataTick> readerWriter = entry.GetDataTickReaderWriter();
List <DataTick> dataTicks;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataTick[] { });
if (readerWriter.Read(request.StartIndex.Value, request.MaxValuesRetrieved.Value, out dataTicks))
{
update.DataTicksUnsafe.AddRange(dataTicks);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return(true);
}
}
else
{
DataReaderWriter <DataBar> readerWriter = entry.GetDataBarReaderWriter();
if (readerWriter == null)
{
SystemMonitor.OperationError("Failed to establish file reader writer for entry.");
return(false);
}
List <DataBar> dataBars;
DataHistoryUpdate update = new DataHistoryUpdate(request.Period, new DataBar[] { });
bool readResult = false;
if (request.StartIndex.Value < 0)
{// Instruction is to read the last count items.
readResult = readerWriter.ReadLast(
request.MaxValuesRetrieved.Value, out dataBars);
}
else
{
readResult = readerWriter.Read(request.StartIndex.Value,
request.MaxValuesRetrieved.Value, out dataBars);
}
if (readResult)
{
update.DataBarsUnsafe.AddRange(dataBars);
if (DataHistoryUpdateEvent != null)
{
DataHistoryUpdateEvent(this, sessionInfo, update);
}
return(true);
}
}
return(false);
};
if (waitResult)
{
return(operationDelegate());
}
else
{
GeneralHelper.FireAndForget(operationDelegate);
return(true);
}
}
