public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
var results = await _aggregatedMetricsRepository.SelectGroupedByStringAsync(
"[Url]",
options.Start,
options.End,
100);
if (results != null)
{
var url = await _contextFacade.GetBaseUrlAsync();
foreach (var result in results.Data)
{
result.Aggregate = result.Aggregate?.ToLower().Replace(url.ToLower(), "");
}
}
return(View(results));
}
public IActionResult ExampleMvc()
{
ChartOptions opts = new ChartOptions();
opts.ChartType = PlotChartType.Line;
opts.Resolution = PlotResolution.None;
opts.Showgrid = true;
opts.XAxis.Datatype = AxisDataType.Numeric;
opts.YAxis.Datatype = AxisDataType.Numeric;
GoogleChart chart = new GoogleChart();
chart.ChartDefinition = opts;
chart.CurveData.Add("My Curve 1", new List <PlotPoint>
{
new PlotPoint(0, 20),
new PlotPoint(1, 30),
new PlotPoint(2, 40),
new PlotPoint(3, 35),
new PlotPoint(4, 15),
new PlotPoint(5, 25)
});
chart.CurveData.Add("My Curve 2", new List <PlotPoint>
{
new PlotPoint(0, 12),
new PlotPoint(1, 13),
new PlotPoint(2, 18),
new PlotPoint(3, 22),
new PlotPoint(4, 42),
new PlotPoint(5, 23)
});
return(View(chart));
}
public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
var data = options.FeatureId > 0
? await _aggregatedEntityRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End,
options.FeatureId)
: await _aggregatedEntityRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End);
return(View(new ChartViewModel <AggregatedResult <DateTimeOffset> >()
{
Options = chart,
Data = data.MergeIntoRange(options.Start, options.End)
}));
}
public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
var data = await _entityStore.QueryAsync()
.Take(1, 10)
.Select <EntityQueryParams>(q =>
{
if (options.FeatureId > 0)
{
q.FeatureId.Equals(options.FeatureId);
}
q.CreatedDate.GreaterThan(options.Start);
q.CreatedDate.LessThanOrEqual(options.End);
})
.OrderBy("CreatedDate", OrderBy.Desc)
.ToList();
return(View(new ChartViewModel <IPagedResults <Entity> >()
{
Options = chart,
Data = data
}));
}
internal static void Generate(Atlas Atlas, ChartOptions ChartOptions)
{
XAtlasPINVOKE.Generate__SWIG_1(Atlas.getCPtr(Atlas), ChartOptions.getCPtr(ChartOptions));
if (XAtlasPINVOKE.SWIGPendingException.Pending)
{
throw XAtlasPINVOKE.SWIGPendingException.Retrieve();
}
}
internal static void ComputeCharts(Atlas Atlas, ChartOptions Options)
{
XAtlasPINVOKE.ComputeCharts__SWIG_0(Atlas.getCPtr(Atlas), ChartOptions.getCPtr(Options));
if (XAtlasPINVOKE.SWIGPendingException.Pending)
{
throw XAtlasPINVOKE.SWIGPendingException.Retrieve();
}
}
public ActionResult Selection(ChartOptions opts)
{
ViewBag.typeIndex = ChartOptions.ChartTypes.IndexOf(opts.type);
ViewBag.stackIndex = ChartOptions.Stackings.IndexOf(opts.stack);
ViewBag.selectionIndex = ChartOptions.SelectionModes.IndexOf(opts.selectionmode);
return(View(opts));
}
/// <summary>
/// OptionsModel.Load is used to set the properties of an existing ChartOptions object in a FlexChart based control.
/// The values used are those stored in an existing OptionsModel class object that is typically created and set by
/// a standard serializer during deserialization.
/// </summary>
/// <param name="options">Specifies an existing instance of a ChartOptions class object.</param>
/// <param name="optionsModel">Specifies an existing instannce of a ChartOptionsModel class object created by a
/// a standard serializer during deserialization.</param>
public static void Load(ChartOptions options, OptionsModel optionsModel)
{
options.BubbleMinSize = optionsModel.BubbleMinSize;
options.BubbleMaxSize = optionsModel.BubbleMaxSize;
options.InterpolateNulls = optionsModel.InterpolateNulls;
options.ClusterSize.SizeType = optionsModel.ClusterSizeType;
options.ClusterSize.Value = optionsModel.ClusterSizeValue;
}
public static HtmlString ScatterChartFor(this IHtmlHelper htmlHelper, ChartOptions chartOptions)
{
chartOptions.ClientId = string.IsNullOrWhiteSpace(chartOptions.ClientId) ? _id.ToString(CultureInfo.InvariantCulture) : chartOptions.ClientId;
var script = GetScriptDependencyInection() + string.Format(ChartContainer, chartOptions.ClientId) +
"<script>" + ScriptBuilder.BuildScatterChart(chartOptions) + "</script>";
return(new HtmlString(script));
}
public ActionResult Selection()
{
ChartOptions opts = new ChartOptions();
ViewBag.typeIndex = 0;
ViewBag.stackIndex = 0;
ViewBag.selectionIndex = 1;
return(View(opts));
}
public void ChartOptions_Serialize()
{
var opt = new ChartOptions
{
Height = 200,
Width = 500
};
var json = opt.ToJson();
}
public void ApexChartTest_EmptyChart()
{
var options = new ChartOptions();
var chart = new ApexChart(ChartName, Selector, options, formatJson: false);
var chartJson = chart.ToString();
var jsonOptionsSample = "{\"chart\":{\"id\":\"" + ChartName + "\"}}";
var chartSample = $"var {ChartName} = new ApexCharts(document.querySelector(\"{Selector}\"), {jsonOptionsSample});" + Environment.NewLine +
$"{ChartName}.render();";
Assert.Equal(chartSample, chartJson);
}
public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
var entities = options.FeatureId > 0
? await _aggregatedEntityRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End,
options.FeatureId)
: await _aggregatedEntityRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End);
var replies = options.FeatureId > 0
? await _aggregatedEntityReplyRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End,
options.FeatureId)
: await _aggregatedEntityReplyRepository.SelectGroupedByDateAsync(
"CreatedDate",
options.Start,
options.End);
var results = new Dictionary <string, ChartViewModel <AggregatedResult <DateTimeOffset> > >();
results.Add("entities", new ChartViewModel <AggregatedResult <DateTimeOffset> >()
{
Options = chart,
Data = entities.MergeIntoRange(options.Start, options.End)
});
results.Add("replies", new ChartViewModel <AggregatedResult <DateTimeOffset> >()
{
Options = chart,
Data = replies.MergeIntoRange(options.Start, options.End)
});
return(View(results));
}
public BatchUserSettings()
{
ProjectFiles = new List <string>();
DiagramOptions = new DiagramOptions();
ForceLayoutConfigutation = new ForceLayoutConfiguration();
ChartOptions = new ChartOptions();
DisplayUnits = new DisplayUnitsManager();
ComparerSettings = new ComparerSettings {
CompareHiddenEntities = true
};
JournalPageEditorSettings = new JournalPageEditorSettings();
ParameterIdentificationFeedbackEditorSettings = new ParameterIdentificationFeedbackEditorSettings();
MergeConflictViewSettings = new MergeConflictViewSettings();
}
public void FrappeChartsTest_EmptyChart()
{
var options = new ChartOptions();
var chart = new FrappeChart(Selector, ChartName, formatJson: false)
{
Options = options
};
var chartJson = chart.ToString();
var jsonOptionsSample = "{}";
var chartSample = $"var {ChartName} = new frappe.Chart(\"{Selector}\", {jsonOptionsSample});" + Environment.NewLine;
Assert.Equal(chartSample, chartJson);
}
private static string DefaultScriptBuilder(ChartOptions chartOptions, RenderType renderType, params string[] aditionalScriptData)
{
const string themeApi = @"var highchartsOptions = Highcharts.setOptions(themes['{0}']);";
chartOptions.Appearance.renderTo = "chart" + chartOptions.ClientId;
chartOptions.Appearance.defaultSeriesType = renderType.ToString();
var scriptBuilder = new StringBuilder();
scriptBuilder.Append("var chart");
scriptBuilder.Append(chartOptions.ClientId);
scriptBuilder.AppendLine(";");
scriptBuilder.AppendLine("$(document).ready(function() {");
scriptBuilder.AppendLine(chartOptions.Lang.ToString());
scriptBuilder.Append("chart");
scriptBuilder.Append(chartOptions.ClientId);
scriptBuilder.AppendLine(" = new Highcharts.Chart({");
aditionalScriptData.ToList().ForEach(ad => scriptBuilder.AppendLine(ad));
scriptBuilder.AppendLine(chartOptions.Appearance != null ? chartOptions.Appearance.ToString() : string.Empty);
scriptBuilder.AppendLine(chartOptions.Colors != null ? chartOptions.Colors.ToString() : string.Empty);
scriptBuilder.AppendLine("credits: { enabled: ");
scriptBuilder.Append(chartOptions.ShowCredits.ToString(CultureInfo.InvariantCulture).ToLower());
scriptBuilder.Append("},");
scriptBuilder.AppendLine(chartOptions.PlotOptions != null ? chartOptions.PlotOptions.ToString() : string.Empty);
scriptBuilder.AppendLine(chartOptions.Title != null ? chartOptions.Title.ToString() : string.Empty);
scriptBuilder.AppendLine(chartOptions.SubTitle != null ? chartOptions.SubTitle.ToString() : string.Empty);
scriptBuilder.AppendLine(chartOptions.Legend != null ? chartOptions.Legend.ToString() : string.Empty);
scriptBuilder.AppendLine(chartOptions.Exporting.ToString());
scriptBuilder.AppendLine(chartOptions.XAxis.ToString());
scriptBuilder.AppendLine(chartOptions.YAxis.ToString());
scriptBuilder.AppendLine(chartOptions.Tooltip.ToString());
scriptBuilder.AppendLine(chartOptions.Series.ToString());
scriptBuilder.AppendLine("});");
scriptBuilder.AppendLine(chartOptions.AjaxDataSource.ToString());
scriptBuilder.AppendLine("});");
var reg = new System.Text.RegularExpressions.Regex(@"\""(function\(event\)\{.*?\})\""",
System.Text.RegularExpressions.RegexOptions.Multiline);
var script = reg.Replace(scriptBuilder.ToString(), "$1");
return(string.IsNullOrEmpty(chartOptions.Theme)
? script
: string.Concat(string.Format(themeApi, chartOptions.Theme), script));
}
public ChartPanel(ChartOptions options)
{
this.SeriesType = options.SeriesType;
this.IndicatorType = options.IndicatorType;
this.ChartDrawing = ChartDrawingHelper.GetChartDrawing(SeriesType, IndicatorType);
this.ChartData = options.ChartData;
this.ChartStyle = options.ChartStyle;
if (this.ChartStyle == null)
{
this.ChartStyle = new DefaultChartStyle();
}
SizeChanged += ChartPanel_SizeChanged;
}
public void ApexChartTest_EmptyOptions()
{
var options = new ChartOptions();
var jsonOptions = JsonConvert.SerializeObject(
options,
Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}
);
var jsonOptionsSample = "{\"chart\":{}}";
Assert.Equal(jsonOptionsSample, jsonOptions);
}
public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
return(View(new ChartViewModel <IEnumerable <AggregatedModel <int, User> > >()
{
Options = chart,
Data = await SelectUsersByReputationAsync(options)
}));
}
public async Task <IViewComponentResult> InvokeAsync(
ReportOptions options,
ChartOptions chart)
{
if (options == null)
{
options = new ReportOptions();
}
if (chart == null)
{
chart = new ChartOptions();
}
var data = await SelectEntitiesGroupedByViewsAsync(options);
return(View(new ChartViewModel <IEnumerable <AggregatedModel <int, Entity> > >()
{
Options = chart,
Data = data
}));
}
public void MainFormAnalyzeChartInputParametersAndCookChartOptionsTest()
{
ChartOptions chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("-10.0", "10.0", "-10.0", "10.0");
Assert.IsTrue(chartOptions.Errors.Count == 0);
Assert.AreEqual(800, chartOptions.SizeX);
Assert.AreEqual(800, chartOptions.SizeY);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("-10", "10", "-5", "5");
Assert.IsTrue(chartOptions.Errors.Count == 0);
Assert.AreEqual(800, chartOptions.SizeX);
Assert.AreEqual(400, chartOptions.SizeY);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("5", "-5", "10", "-10");
Assert.IsTrue(chartOptions.Errors.Count == 0);
Assert.AreEqual(400, chartOptions.SizeX);
Assert.AreEqual(800, chartOptions.SizeY);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("5", "5", "10", "10");
Assert.AreEqual(2, chartOptions.Errors.Count);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("-2000", "2000", "-2000", "2000");
Assert.AreEqual(4, chartOptions.Errors.Count);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("-10", "10", "-1000", "1000");
Assert.AreEqual(1, chartOptions.Errors.Count);
chartOptions =
MainForm.AnalyzeChartInputParametersAndCookChartOptions("1000", "-1000", "10", "-10");
Assert.AreEqual(1, chartOptions.Errors.Count);
}
public void Generate(ChartOptions chartOptions, PackOptions packOptions) => XAtlas.Generate(this, chartOptions, packOptions);
public void ComputeCharts(ChartOptions options) => XAtlas.ComputeCharts(this, options);
public void Show(ChartOptions chartOptions)
{
_screenBinder.BindToSource(chartOptions);
}
private IEnumerable <string> getDefaultLayoutNames(ChartOptions chartOptions)
{
return(_chartLayoutTemplateRepository.All().Select(x => x.Name));
}
private IEnumerable <Scalings> getAllScalings(ChartOptions arg)
{
return(EnumHelper.AllValuesFor <Scalings>());
}
internal StatGroup(string name, ChartOptions chartData)
{
this.name = name;
this.chartData = chartData;
}
/// <summary>
/// Initializes a new instance of the <see cref="TableColumn" /> class.
/// </summary>
public TableColumn()
{
this.CellStyleKey = SharedMapStyleKeys.CellExport;
this.HeaderStyleKey = SharedMapStyleKeys.ColumnHeaderExport;
this.chartOptions = new ChartOptions();
}
public void BarChartYAxisFormat()
{
var options = new ChartOptions();
var series = new List <ChartSeries>()
{
new ChartSeries()
{
Name = "Series 1", Data = new double[] { 90, 79, 72, 69, 62, 62, 55, 65, 70 }
},
new ChartSeries()
{
Name = "Series 2", Data = new double[] { 10, 41, 35, 51, 49, 62, 69, 91, 148 }
},
};
var xAxis = new string[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep" };
var width = "100%";
var height = "350px";
var comp = Context.RenderComponent <MudChart>(parameters => parameters
.Add(p => p.ChartType, ChartType.Line)
.Add(p => p.ChartSeries, series)
.Add(p => p.XAxisLabels, xAxis)
.Add(p => p.ChartOptions, options)
.Add(p => p.Width, width)
.Add(p => p.Height, height)
);
// check the first Y Axis value without any format
var yaxis = comp.FindAll("g.mud-charts-yaxis");
yaxis.Should().NotBeNull();
yaxis[0].Children[0].InnerHtml.Trim().Should().Be("0");
// now, we will apply currency format
options.YAxisFormat = "c2";
comp.SetParametersAndRender(parameters => parameters
.Add(p => p.ChartType, ChartType.Line)
.Add(p => p.ChartSeries, series)
.Add(p => p.XAxisLabels, xAxis)
.Add(p => p.ChartOptions, options)
.Add(p => p.Width, width)
.Add(p => p.Height, height)
);
yaxis = comp.FindAll("g.mud-charts-yaxis");
yaxis.Should().NotBeNull();
yaxis[0].Children[0].InnerHtml.Trim().Should().Be($"{0:c2}");
//number format
options.YAxisFormat = "n6";
comp.SetParametersAndRender(parameters => parameters
.Add(p => p.ChartType, ChartType.Line)
.Add(p => p.ChartSeries, series)
.Add(p => p.XAxisLabels, xAxis)
.Add(p => p.ChartOptions, options)
.Add(p => p.Width, width)
.Add(p => p.Height, height)
);
yaxis = comp.FindAll("g.mud-charts-yaxis");
yaxis.Should().NotBeNull();
yaxis[0].Children[0].InnerHtml.Trim().Should().Be($"{0:n6}");
}
/// <summary>
/// Gets a specific set of line charts that are either Altitude or Speed
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
List<LineChart> getLineCharts(ChartOptions option)
{
List<LineChart> charts = new List<LineChart>();
switch (option)
{
case ChartOptions.ALTITUDE:
foreach (IPlotterElement child in innerAltitudePlotter.Children)
if (typeof(LineChart) == child.GetType())
charts.Add((LineChart)child);
break;
case ChartOptions.SPEED:
foreach (IPlotterElement child in innerSpeedPlotter.Children)
if (typeof(LineChart) == child.GetType())
charts.Add((LineChart)child);
break;
}
return charts;
}
/// <summary>
/// This method can return at most one chart meeting both the specified criteria.
/// </summary>
/// <param name="lap"></param>
/// <param name="option"></param>
/// <returns>The LineChart of the chart matching criteria. If one is not found, return null</returns>
LineChart getLineCharts(LapInfo lap, ChartOptions option)
{
switch (option)
{
case ChartOptions.ALTITUDE:
foreach (IPlotterElement child in innerAltitudePlotter.Children)
{
if (typeof(LineChart) == child.GetType())
{
LineChart chart = child as LineChart;
if (lap.Equals((LapInfo)chart.Tag)) // find the chart that matches the lap object
{
return chart;
}
}
}
break;
case ChartOptions.SPEED:
foreach (IPlotterElement child in innerSpeedPlotter.Children)
{
if (typeof(LineChart) == child.GetType())
{
LineChart chart = child as LineChart;
if (lap.Equals((LapInfo)chart.Tag)) // find the chart that matches the lap object
{
return chart;
}
}
}
break;
}
return null;
}
public ChartData()
{
Data = new List <int>();
Labels = new List <string>();
Options = new ChartOptions();
}
