public void AddFigure(IFigureDescriptor descriptor, FigureConfig config)
{
var figureProxy = new FigureProxy(descriptor);
figureProxy.LoadConfig(config);
FigureCollection.AddFigure(figureProxy);
}
public void Reset()
{
CurrentFigureDescriptor = null;
CurrentSource = null;
Sources.Clear();
}
public void FailedToParseDocument(IFigureDescriptor figureDescriptor, string error)
{
var vm = Sources
.SelectMany(s => s.Figures)
.Single(f => f.Model == figureDescriptor);
vm.ValidationResult = error;
}
public void ParsingSucceeded(IFigureDescriptor figureDescriptor)
{
var vm = Sources
.SelectMany(s => s.Figures)
.Single(f => f.Model == figureDescriptor);
vm.ValidationResult = DataSourceViewModel.ValidationSucceeded;
}
public void AddFigure(IFigureDescriptor descriptor)
{
var figureProxy = new FigureProxy(descriptor);
FigureCollection.AddFigure(figureProxy);
var figureSetup = new FigureSetupViewModel(this, figureProxy);
WindowManager.ShowDialog(figureSetup);
}
private void Validate(DataSource source, IFigureDescriptor figureDescriptor)
{
try
{
Browser.Navigate(DocumentType.Html, source.Location, new StockMacroResolver(SelectedStock));
myValidationReport.NavigationSucceeded(source);
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendLine(ex.Message);
foreach (var key in ex.Data.Keys)
{
sb.AppendFormat("{0}: {1}", key, ex.Data[key]);
sb.AppendLine();
}
myValidationReport.FailedToLocateDocument(source, sb.ToString());
return;
}
// The new document is automatically given to the selected FigureDescriptor ViewModel.
// The MarkupBehavior gets automatically applied
var parser = DocumentProcessingFactory.CreateParser(Browser.Document, figureDescriptor);
try
{
var table = parser.ExtractTable();
if (table.Rows.Count == 0)
{
myValidationReport.FailedToParseDocument(figureDescriptor, "Unknown reason");
}
else
{
myValidationReport.ParsingSucceeded(figureDescriptor);
}
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendLine(ex.Message);
foreach (var key in ex.Data.Keys)
{
sb.AppendFormat("{0}: {1}", key, ex.Data[key]);
sb.AppendLine();
}
myValidationReport.FailedToParseDocument(figureDescriptor, sb.ToString());
}
}
/// <summary>
/// Gets an instance of <see cref="IFigureDescriptor"/> for the specific <see cref="FigureType"/>.
/// </summary>
/// <param name="figureType">Type of the figure.</param>
/// <returns>An instance of <see cref="IFigureDescriptor"/>.</returns>
public IFigureDescriptor GetDescriptorFor(FigureType figureType)
{
IFigureDescriptor descriptor = _descriptors.GetValueOrDefault(figureType);
if (descriptor == null)
{
throw new InvalidOperationException($"No figure descriptor found for {figureType}. You need to add it.");
}
return(descriptor);
}
public IDescriptorViewModel Create(IFigureDescriptor descriptor)
{
Contract.RequiresNotNull(descriptor, "descriptor ");
if (descriptor is PathCellDescriptor)
{
return(new PathCellDescriptorViewModel(myLutService, descriptor as PathCellDescriptor));
}
if (descriptor is PathSeriesDescriptor)
{
return(new PathSeriesDescriptorViewModel(descriptor as PathSeriesDescriptor));
}
throw new NotSupportedException("Unknown descriptor type: " + descriptor.GetType().Name);
}
private void ValidateFigureProps(IDictionary <string, double> figureProps, CustomContext context)
{
// We need to find out FigureType so we get model from the ParentContext.
// DO NOT use RuleFor(model => model).Custom(ValidateFigureProps); in constructor because in this case context.PropertyName will be null.
// So the client don't understand to which property an error message refers.
var model = (PostFigureModel)context.ParentContext.InstanceToValidate;
IFigureDescriptor figureDescriptor = _figureDescriptorProvider.GetDescriptorFor(model.FigureType);
ValidationResult validationResult = figureDescriptor.ValidateProps(figureProps);
foreach (ValidationFailure failure in validationResult.Errors)
{
string propertyName = failure.PropertyName == null ? context.PropertyName : $"{context.PropertyName}.{failure.PropertyName}";
context.AddFailure(new ValidationFailure(propertyName, failure.ErrorMessage, failure.AttemptedValue));
}
}
public static IDocumentParser CreateParser(IDocument document, IFigureDescriptor descriptor)
{
Contract.RequiresNotNull(document, "document");
Contract.RequiresNotNull(descriptor, "descriptor");
var htmlDocument = document as IHtmlDocument;
if (htmlDocument != null)
{
return(new HtmlParser(htmlDocument, descriptor));
}
var textDocument = document as TextDocument;
if (textDocument != null)
{
return(new TextParser(textDocument, descriptor));
}
throw new NotSupportedException("Unable to find parser for document type: " + document.GetType());
}
public void GetDescriptorFor_ShouldReturnDescriptor_WhenFound()
{
// Arrange
FigureType[] figureTypes = _fixture
.CreateMany <FigureType>()
.Distinct()
.ToArray();
IEnumerable <IFigureDescriptor> descriptors = CreateDescriptors(figureTypes);
var provider = new FigureDescriptorProvider(descriptors);
FigureType testFigureType = figureTypes.First();
// Act
IFigureDescriptor descriptor = provider.GetDescriptorFor(testFigureType);
// Assert
Assert.NotNull(descriptor);
Assert.Equal(testFigureType, descriptor.FigureType);
}
public static IDataTableToEntityConverter CreateConverter(IFigureDescriptor descriptor, DataSource dataSource, IEnumerable <Currency> currencies)
{
Contract.RequiresNotNull(descriptor, "descriptor");
var entityType = Dynamics.AllFigures.SingleOrDefault(f => f.Name == descriptor.Figure);
Contract.Requires(entityType != null, "No entity of type {0} found", descriptor.Figure);
var source = dataSource.Vendor + "|" + dataSource.Name;
if (descriptor is SeriesDescriptorBase)
{
return(new DataTableToSeriesConverter(descriptor as SeriesDescriptorBase, entityType, source, currencies));
}
if (descriptor is SingleValueDescriptorBase)
{
return(new DataTableToSingleValueConverter(descriptor as SingleValueDescriptorBase, entityType, source, currencies));
}
//if( descriptor is TableDescriptorBase ) return new DataTableToTableConverter( descriptor as TableDescriptorBase, entityType, source );
throw new NotSupportedException("Unknown descriptor type: " + descriptor.GetType().Name);
}
public FigureProxy(IFigureDescriptor descriptor) : base(descriptor)
{
_figure = descriptor.CreateInstance();
Parameters = new ParameterCollection();
RegisterParameters();
}
public HtmlParser(IHtmlDocument document, IFigureDescriptor descriptor)
{
myDocument = document;
myDescriptor = descriptor;
}
public TextParser(TextDocument textDocument, IFigureDescriptor descriptor)
{
myDocument = textDocument;
myDescriptor = descriptor;
}
public FigureViewModel(Session session, DataSourceViewModel parent, IFigureDescriptor model)
: base(session)
{
myParent = parent;
Model = model;
}
public LibraryFigureViewModel(IFigureDescriptor figureDescriptor)
{
Descriptor = figureDescriptor;
}
