private List <FinancialStatement> ParseFinancialStatements(string jsonData, string frequency)
{
dynamic statements = JObject.Parse(jsonData);
var results = new List <FinancialStatement>();
if (statements != null && statements.result != null && statements.result.rows != null)
{
foreach (var row in statements.result.rows.Children())
{
FinancialStatement statement = new FinancialStatement {
Source = frequency
};
foreach (var entry in row.values.Children())
{
string field = entry.field;
string value = entry.value;
if (Setters.ContainsKey(field) && value != null && value != "null")
{
Setters[field](statement, value);
}
}
results.Add(statement);
}
}
return(results);
}
public DependencyProperty(XamlAstClrProperty original, IXamlProperty dependencyPropertyProp,
WellKnownWinUITypes types)
: base(original, original.Name, original.DeclaringType, original.Getter, original.Setters)
{
dependencyProperty = dependencyPropertyProp;
Setters.Insert(0, new BindingSetter(types, original.DeclaringType, dependencyPropertyProp));
}
public void TestBorderThickness()
{
var setter = Setters.BorderThickness(2);
setter.Property.Should().Be(Control.BorderThicknessProperty);
setter.Value.Should().BeEquivalentTo(new Thickness(2));
}
public XamlAstClrProperty(IXamlLineInfo lineInfo, IXamlProperty property,
TransformerConfiguration cfg) : base(lineInfo)
{
Name = property.Name;
Getter = property.Getter;
if (property.Setter != null)
{
Setters.Add(new XamlDirectCallPropertySetter(property.Setter));
}
CustomAttributes = property.CustomAttributes.ToList();
DeclaringType = (property.Getter ?? property.Setter)?.DeclaringType;
var typeConverterAttributes = cfg.GetCustomAttribute(property, cfg.TypeMappings.TypeConverterAttributes);
if (typeConverterAttributes != null)
{
foreach (var attr in typeConverterAttributes)
{
var typeConverter =
XamlTransformHelpers.TryGetTypeConverterFromCustomAttribute(cfg, attr);
if (typeConverter != null)
{
TypeConverters[property.PropertyType] = typeConverter;
break;
}
}
}
}
public void TestSnapsToPixels()
{
var setter = Setters.SnapsToPixels(true);
setter.Property.Should().Be(UIElement.SnapsToDevicePixelsProperty);
setter.Value.Should().Be(true);
}
public void TestIsTabStop()
{
var setter = Setters.IsTabStop(false);
setter.Property.Should().Be(Control.IsTabStopProperty);
setter.Value.Should().Be(false);
}
public void TestVContentAlign()
{
var setter = Setters.VContentAlign(VerticalAlignment.Bottom);
setter.Property.Should().Be(Control.VerticalContentAlignmentProperty);
setter.Value.Should().Be(VerticalAlignment.Bottom);
}
public void TestHContentAlign()
{
var setter = Setters.HContentAlign(HorizontalAlignment.Right);
setter.Property.Should().Be(Control.HorizontalContentAlignmentProperty);
setter.Value.Should().Be(HorizontalAlignment.Right);
}
public void TestTabIndex()
{
var setter = Setters.TabIndex(5);
setter.Property.Should().Be(Control.TabIndexProperty);
setter.Value.Should().Be(5);
}
public void TestFontWeight()
{
var setter = Setters.FontWeight(FontWeights.Bold);
setter.Property.Should().Be(Control.FontWeightProperty);
setter.Value.Should().Be(FontWeights.Bold);
}
public XamlIlAvaloniaProperty(XamlAstClrProperty original, IXamlField field,
AvaloniaXamlIlWellKnownTypes types)
: base(original, original.Name, original.DeclaringType, original.Getter, original.Setters)
{
var assignBinding = original.CustomAttributes.Any(ca => ca.Type.Equals(types.AssignBindingAttribute));
AvaloniaProperty = field;
CustomAttributes = original.CustomAttributes;
if (!assignBinding)
{
Setters.Insert(0, new BindingSetter(types, original.DeclaringType, field));
}
// Styled and attached properties can be set with a BindingPriority when they're
// assigned in a ControlTemplate.
if (field.FieldType.GenericTypeDefinition == types.StyledPropertyT ||
field.FieldType.GenericTypeDefinition == types.AvaloniaAttachedPropertyT)
{
var propertyType = field.FieldType.GenericArguments[0];
Setters.Insert(0, new SetValueWithPrioritySetter(types, original.DeclaringType, field, propertyType));
if (!assignBinding)
{
Setters.Insert(1, new BindingWithPrioritySetter(types, original.DeclaringType, field));
}
}
Setters.Insert(0, new UnsetValueSetter(types, original.DeclaringType, field));
}
public override void SetValue(string propertyName, object value)
{
switch (propertyName)
{
case "ParameterID": this.ParameterID = Setters.Int(value); break;
case "ProcedureID": this.ProcedureID = Setters.Int(value); break;
case "Scale": this.Scale = Setters.Byte(value); break;
case "SqlDbType": this.SqlDbType = Setters.Int(value); break;
case "Precision": this.Precision = Setters.Byte(value); break;
case "Size": this.Size = Setters.Int(value); break;
case "Direction": this.Direction = Setters.Int(value); break;
case "DefaultValue": this.DefaultValue = Setters.String(value); break;
case "Name": this.Name = Setters.String(value); break;
case "SourceColumn": this.SourceColumn = Setters.String(value); break;
default:
break;
}
}
public void TestForeground()
{
var setter = Setters.Foreground(Brushes.Red);
setter.Property.Should().Be(Control.ForegroundProperty);
setter.Value.Should().Be(Brushes.Red);
}
public override void SetValue(string propertyName, object value)
{
switch (propertyName)
{
case "EnumID": this.EnumID = Setters.Int(value); break;
case "Name": this.Name = Setters.String(value); break;
case "HasFlags": this.HasFlags = Setters.Bool(value); break;
case "ConnectionID": this.ConnectionID = Setters.Int(value); break;
case "TableName": this.TableName = Setters.String(value); break;
case "ValueColumn": this.ValueColumn = Setters.String(value); break;
case "DisplayColumn": this.DisplayColumn = Setters.String(value); break;
case "IncludeNoneValue": this.IncludeNoneValue = Setters.Bool(value); break;
case "FilterColumn": this.FilterColumn = Setters.String(value); break;
case "FilterValue": this.FilterValue = Setters.String(value); break;
case "ProjectID": this.ProjectID = Setters.Int(value); break;
default:
break;
}
}
public void TestFontStyle()
{
var setter = Setters.FontStyle(FontStyles.Italic);
setter.Property.Should().Be(Control.FontStyleProperty);
setter.Value.Should().Be(FontStyles.Italic);
}
public void TestFontStretch()
{
var setter = Setters.FontStretch(FontStretches.Expanded);
setter.Property.Should().Be(Control.FontStretchProperty);
setter.Value.Should().Be(FontStretches.Expanded);
}
public void TestFontFamily()
{
var setter = Setters.FontFamily("Arial");
setter.Property.Should().Be(Control.FontFamilyProperty);
setter.Value.Should().BeEquivalentTo(new FontFamily("Arial"));
}
public InstanceConstructorFrame(ConstructorInstance instance, DisposeTracking disposal, Variable[] arguments,
SetterArg[] setterParameters) : base(instance.ImplementationType, instance.Constructor, f => new ServiceVariable(instance, f, ServiceDeclaration.ServiceType))
{
Disposal = disposal;
Parameters = arguments;
switch (disposal)
{
case DisposeTracking.None:
Mode = ConstructorCallMode.Variable;
break;
case DisposeTracking.WithUsing:
Mode = ConstructorCallMode.UsingNestedVariable;
break;
case DisposeTracking.RegisterWithScope:
Mode = ConstructorCallMode.Variable;
var addDisposable = MethodCall.For <Scope>(s => s.TryAddDisposable(null));
addDisposable.Arguments[0] = Variable;
ActivatorFrames.Add(addDisposable);
break;
}
Setters.AddRange(setterParameters);
}
public AvaloniaAttachedInstanceProperty(XamlAstNamePropertyReference prop,
TransformerConfiguration config,
IXamlType declaringType,
IXamlType type,
IXamlType avaloniaPropertyType,
IXamlType avaloniaObject,
IXamlField field) : base(prop, prop.Name,
declaringType, null)
{
_config = config;
_declaringType = declaringType;
_avaloniaPropertyType = avaloniaPropertyType;
// XamlIl doesn't support generic methods yet
if (_avaloniaPropertyType.GenericArguments?.Count > 0)
{
_avaloniaPropertyType = _avaloniaPropertyType.BaseType;
}
_avaloniaObject = avaloniaObject;
_field = field;
PropertyType = type;
Setters.Add(new SetterMethod(this));
Getter = new GetterMethod(this);
}
public void TestBorderBrush()
{
var setter = Setters.BorderBrush(Brushes.Yellow);
setter.Property.Should().Be(Control.BorderBrushProperty);
setter.Value.Should().Be(Brushes.Yellow);
}
public void TestFontSize()
{
var setter = Setters.FontSize(20);
setter.Property.Should().Be(Control.FontSizeProperty);
setter.Value.Should().Be(20);
}
public override void SetValues(object[] values, Dictionary <string, MapPoint> map)
{
this.ProjectProcedureID = Setters.Int(values, map["ProjectProcedureID"], ProjectProcedureID);
this.ProjectID = Setters.Int(values, map["ProjectID"], ProjectID);
this.CommandText = Setters.String(values, map["CommandText"], CommandText);
this.Alias = Setters.String(values, map["Alias"], Alias);
this.Wrapper = Setters.String(values, map["Wrapper"], Wrapper);
}
public override void SetValues(System.Data.IDataReader reader, Dictionary <string, MapPoint> map)
{
this.ProjectProcedureID = Setters.Int(reader, map["ProjectProcedureID"], ProjectProcedureID);
this.ProjectID = Setters.Int(reader, map["ProjectID"], ProjectID);
this.CommandText = Setters.String(reader, map["CommandText"], CommandText);
this.Alias = Setters.String(reader, map["Alias"], Alias);
this.Wrapper = Setters.String(reader, map["Wrapper"], Wrapper);
}
/// <summary>
/// Used to provider a custom setting actions. This setters will be invoked just after the new
/// value is set on the property. They setters will be executed in the same order they are defined
/// </summary>
/// <param name="setters">A list of setters</param>
/// <returns>this</returns>
public ViewModelPropertyDescriptor <TOwner, TResult> Set(params Action <TResult>[] setters)
{
foreach (var setter in setters)
{
Setters.Add(setter);
}
return(this);
}
public FlowActivityDefinition <TReq, TRes> SetValue <TVal>(Expression <Func <TReq, TVal> > propertyExpression, TVal value)
{
var requestSetInputProperty = ReflectionUtils.GetProperty(propertyExpression);
Setters.Add(new Tuple <PropertyInfo, object>(requestSetInputProperty, value));
AddFlowValueBinding <TReq, TRes>(requestSetInputProperty);
return(this);
}
public void TestTemplate()
{
var template = new ControlTemplate(typeof(Button));
var setter = Setters.Template(template);
setter.Property.Should().Be(Control.TemplateProperty);
setter.Value.Should().Be(template);
}
public void add(DependencyProperty property, object value)
{
Setters.Add(new Setter()
{
Property = property,
Value = value
});
}
public override void SetValues(object[] values, Dictionary <string, MapPoint> map)
{
this.ProjectID = Setters.Int(values, map["ProjectID"], ProjectID);
this.Name = Setters.String(values, map["Name"], Name);
this.BuildPath = Setters.String(values, map["BuildPath"], BuildPath);
this.PublishPath = Setters.String(values, map["PublishPath"], PublishPath);
this.Namespace = Setters.String(values, map["Namespace"], Namespace);
this.DefaultConnectionString = Setters.String(values, map["DefaultConnectionString"], DefaultConnectionString);
}
public void Update()
{
Setters.Clear();
Triggers.Clear();
_nativeStyle = null;
OnStyleChanged();
}
public override void InitStats()
{
base.InitStats();
Getters.Add("Killstreak", delegate() { return(Killstreak); });
Setters.Add("Killstreak", delegate(object val) { Killstreak = (int)val; });
}
