private IDictionary <string, object> SerializePopUp()
{
var result = new Dictionary <string, object>();
var title = PopUp.Title ?? Messages.Grid_Edit;
FluentDictionary.For(result)
.Add("title", title)
.Add("modal", PopUp.Modal)
.Add("draggable", PopUp.Draggable)
.Add("resizable", PopUp.ResizingSettings.Enabled)
.Add("width", PopUp.Width, 0)
.Add("height", PopUp.Height, 0);
if (PopUp.PositionSettings.Left != int.MinValue || PopUp.PositionSettings.Top != int.MinValue)
{
var topLeft = new Dictionary <string, int>();
if (PopUp.PositionSettings.Top != int.MinValue)
{
topLeft.Add("top", PopUp.PositionSettings.Top);
}
if (PopUp.PositionSettings.Left != int.MinValue)
{
topLeft.Add("left", PopUp.PositionSettings.Left);
}
result.Add("position", topLeft);
}
return(result);
}
protected override void Serialize(IDictionary <string, object> json)
{
var editorHtml = grid.EditorHtml;
if (editorHtml != null && IsClientBinding)
{
if (grid.IsInClientTemplate)
{
editorHtml = Regex.Replace(editorHtml, "(&)#([0-9]+;)", "$1\\\\#$2");
}
editorHtml = editorHtml.Trim()
.Replace("\r\n", string.Empty)
.Replace("</script>", "<\\/script>")
.Replace("jQuery(\"#", "jQuery(\"\\\\#")
.Replace("#", "\\#");
}
FluentDictionary.For(json)
.Add("confirmation", Confirmation, () => DisplayDeleteConfirmation)
.Add("confirmDelete", ConfirmDelete)
.Add("cancelDelete", CancelDelete)
.Add("mode", Mode.ToString().ToLowerInvariant())
.Add("template", editorHtml, () => Mode != GridEditMode.InLine)
//TODO: Implement GridBeginEditEvent option
//.Add("beginEdit", BeginEdit == GridBeginEditEvent.Click ? "click" : "dblclick", () => BeginEdit != GridBeginEditEvent.Auto)
.Add("createAt", CreateAt.ToString().ToLower(), () => CreateAt != GridInsertRowPosition.Top)
.Add("window", SerializePopUp(), () => Mode == GridEditMode.PopUp && IsClientBinding)
.Add("create", IsClientBinding)
.Add("update", IsClientBinding)
.Add("destroy", IsClientBinding);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", series.Type)
.Add("dynamicHeight", series.DynamicHeight, () => { return(series.DynamicHeight != true); })
.Add("dynamicSlope", series.DynamicSlope, () => { return(series.DynamicSlope != false); })
.Add("neckRatio", series.NeckRatio, () => { return(series.NeckRatio != 0.3); })
.Add("segmentSpacing", series.SegmentSpacing, () => { return(series.SegmentSpacing != 0); })
.Add("field", series.Member, () => series.Member != null)
.Add("categoryField", series.CategoryMember, () => series.CategoryMember != null)
.Add("colorField", series.ColorMember, () => series.ColorMember != null)
.Add("visibleInLegendField", series.VisibleInLegendMember, () => series.VisibleInLegendMember != null)
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("border", series.Border.CreateSerializer().Serialize(), ShouldSerializeBorder);
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
return(result);
}
public IDictionary <string, object> Serialize()
{
var result = new Dictionary <string, object>();
#if MVC2 || MVC3
var editorHtml = grid.EditorHtml;
if (editorHtml != null)
{
editorHtml = editorHtml.Replace("%", "%25").Replace("<", "%3c").Replace(">", "%3e");
}
#endif
FluentDictionary.For(result)
.Add("confirmDelete", DisplayDeleteConfirmation, true)
.Add("mode", Mode.ToString())
#if MVC2 || MVC3
.Add("editor", editorHtml, () => Mode != GridEditMode.InLine)
.Add("beginEdit", BeginEdit == GridBeginEditEvent.Click ? "click" : "dblclick", () => BeginEdit != GridBeginEditEvent.Auto)
.Add("defaultDataItem", SerializeDefaultDataItem(), () => grid.IsClientBinding && DefaultDataItem() != null)
.Add("insertRowPosition", InsertRowPosition.ToString().ToLower(), () => InsertRowPosition != GridInsertRowPosition.Top)
#endif
.Add("popup", SerializePopUp(), () => Mode == GridEditMode.PopUp && grid.IsClientBinding);
return(result);
}
public virtual IDictionary <string, object> Serialize()
{
IDictionary <string, object> windowDictionary = new Dictionary <string, object>();
if (marker.Window != null)
{
FluentDictionary.For(windowDictionary)
.Add("content", marker.Window.Content)
.Add("disableAutoPan", marker.Window.DisableAutoPan, () => marker.Window.DisableAutoPan)
.Add("openOnRightClick", marker.Window.OpenOnRightClick, () => marker.Window.OpenOnRightClick)
.Add("lat", marker.Window.Latitude, () => marker.Latitude != marker.Window.Latitude)
.Add("lng", marker.Window.Longitude, () => marker.Longitude != marker.Window.Longitude)
.Add("maxWidth", marker.Window.MaxWidth, () => marker.Window.MaxWidth != 0)
.Add("zIndex", marker.Window.zIndex, () => marker.Window.zIndex != 0);
}
IDictionary <string, object> result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("id", marker.Id, () => marker.Id != null)
.Add("address", marker.Address, () => marker.Address != null)
.Add("title", marker.Title, () => marker.Title != null)
.Add("lat", marker.Latitude, () => marker.Latitude != null)
.Add("lng", marker.Longitude, () => marker.Latitude != null)
.Add("zIndex", marker.zIndex, 0)
.Add("clickable", marker.Clickable, true)
.Add("draggable", marker.Draggable, false)
.Add("icon", marker.Icon, () => marker.Icon != null)
.Add("window", windowDictionary, () => marker.Window != null);
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", series.Type)
.Add("aggregates", series.Aggregates.CreateSerializer().Serialize(), ShouldSerializeAggregates)
.Add("gap", series.Gap, () => series.Gap.HasValue)
.Add("spacing", series.Spacing, () => series.Spacing.HasValue)
.Add("axis", series.Axis, () => series.Axis.HasValue())
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("border", series.Border.CreateSerializer().Serialize(), ShouldSerializeBorder)
.Add("color", series.Color, () => series.Color.HasValue())
.Add("colorField", series.ColorMember, () => series.ColorMember.HasValue())
.Add("openField", series.OpenMember, () => series.OpenMember.HasValue())
.Add("highField", series.HighMember, () => series.HighMember.HasValue())
.Add("lowField", series.LowMember, () => series.LowMember.HasValue())
.Add("closeField", series.CloseMember, () => series.CloseMember.HasValue());
var line = series.Line.CreateSerializer().Serialize();
if (line.Count > 0)
{
result.Add("line", line);
}
return(result);
}
protected override void Serialize(IDictionary <string, object> json)
{
FluentDictionary.For(json)
.Add("name", Name, DefaultName)
.Add("size", Size, DefaultSize)
.Add("extension", Extension, DefaultExtension);
}
public virtual IDictionary <string, object> Serialize()
{
var result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("position", note.Position.ToString().ToLowerInvariant(), () => note.Position.HasValue);
var labelData = note.Label.CreateSerializer().Serialize();
if (labelData.Count > 0)
{
result.Add("label", labelData);
}
var iconData = note.Icon.CreateSerializer().Serialize();
if (iconData.Count > 0)
{
result.Add("icon", labelData);
}
var lineData = note.Line.CreateSerializer().Serialize();
if (lineData.Count > 0)
{
result.Add("line", lineData);
}
return(result);
}
/// <summary>
/// Binds the series
/// </summary>
protected void BindChartData()
{
if (Chart.DataSource != null)
{
var dataList = new List <IDictionary <string, object> >();
foreach (var dataPoint in Chart.DataSource)
{
var pieChartPoint = new Dictionary <string, object>();
var fluentDictionary = FluentDictionary.For(pieChartPoint);
fluentDictionary.Add("value", Value(dataPoint));
if (Category != null)
{
fluentDictionary.Add("category", Category(dataPoint), (string)null);
}
if (Color != null)
{
fluentDictionary.Add("color", Color(dataPoint), (string)null);
}
if (Explode != null)
{
fluentDictionary.Add("explode", Explode(dataPoint), false);
}
dataList.Add(pieChartPoint);
}
Data = dataList;
}
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("min", axis.Min, () => axis.Min.HasValue)
.Add("max", axis.Max, () => axis.Max.HasValue)
.Add("majorUnit", axis.MajorUnit, () => axis.MajorUnit.HasValue)
.Add("minorUnit", axis.MinorUnit, () => axis.MinorUnit.HasValue);
if (axis.BaseUnit != null)
{
result.Add("baseUnit", axis.BaseUnit.ToString().ToLowerInvariant());
}
if (axis.AxisCrossingValues.Count() > 0)
{
var crossingValues =
from ac in axis.AxisCrossingValues.AsQueryable()
select ac.ToJavaScriptString();
result.Add("axisCrossingValue", crossingValues.ToArray());
}
var notes = axis.Notes.CreateSerializer().Serialize();
if (notes.Count > 0)
{
result.Add("notes", notes);
}
return(result);
}
protected IDictionary <object, object> FieldNameAsKeyFormat(object field, object fieldValue, Action <FluentDictionary <object, object> > moreProperties = null)
{
var dict = new FluentDictionary <object, object> {
{ field, fieldValue },
};
if (moreProperties != null)
{
moreProperties(dict);
}
var fb = (IFilter)this;
if (fb.Cache.HasValue)
{
dict.Add("_cache", fb.Cache);
}
if (!fb.FilterName.IsNullOrEmpty())
{
dict.Add("_name", fb.FilterName);
}
if (!fb.CacheKey.IsNullOrEmpty())
{
dict.Add("_cache_key", fb.CacheKey);
}
return(dict);
}
public virtual IDictionary <string, object> Serialize()
{
var result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("name", series.Name, string.Empty)
.Add("opacity", series.Opacity, () => series.Opacity.HasValue)
.Add("axis", series.Axis, string.Empty)
.Add("groupNameTemplate", series.GroupNameTemplate, string.Empty);
var tooltipData = series.Tooltip.CreateSerializer().Serialize();
if (tooltipData.Count > 0)
{
result.Add("tooltip", tooltipData);
}
var highlightData = series.Highlight.CreateSerializer().Serialize();
if (highlightData.Count > 0)
{
result.Add("highlight", highlightData);
}
return(result);
}
public virtual IDictionary <string, object> Serialize()
{
var result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("opacity", highlight.Opacity, () => highlight.Opacity.HasValue)
.Add("color", highlight.Color, () => highlight.Color.HasValue())
.Add("visible", highlight.Visible, () => highlight.Visible.HasValue);
var borderData = highlight.Border.CreateSerializer().Serialize();
if (borderData.Count > 0)
{
result.Add("border", borderData);
}
var lineData = highlight.Line.CreateSerializer().Serialize();
if (lineData.Count > 0)
{
result.Add("line", lineData);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", series.Orientation == ChartSeriesOrientation.Horizontal ? "line" : "verticalLine")
.Add("stack", series.Stacked, false)
.Add("field", series.Member, () => { return(series.Data == null && series.Member.HasValue()); })
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("width", series.Width, () => series.Width.HasValue)
.Add("color", series.Color, () => series.Color.HasValue())
.Add("dashType", series.DashType.ToString().ToLowerInvariant(), () => series.DashType.HasValue)
.Add("missingValues", series.MissingValues.ToString().ToLowerInvariant(),
() => series.MissingValues.HasValue);
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
var markers = series.Markers.CreateSerializer().Serialize();
if (markers.Count > 0)
{
result.Add("markers", markers);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", "pie")
.Add("field", series.Member, () => { return(series.Data == null && series.Member != null); })
.Add("categoryField", series.CategoryMember, () => { return(series.Data == null && series.CategoryMember != null); })
.Add("explodeField", series.ExplodeMember, () => { return(series.Data == null && series.ExplodeMember != null); })
.Add("colorField", series.ColorMember, () => { return(series.Data == null && series.ColorMember != null); })
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("padding", series.Padding, ChartDefaults.PieSeries.Padding)
.Add("startAngle", series.StartAngle, ChartDefaults.PieSeries.StartAngle);
if (series.Overlay != null)
{
result.Add("overlay", series.Overlay.Value);
}
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
var connectors = series.Connectors.CreateSerializer().Serialize();
if (connectors.Count > 0)
{
result.Add("connectors", connectors);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", axis.Type.ToString().ToLower(), () => axis.Type != null)
.Add("field", axis.Member, () => axis.Categories == null && axis.Member != null)
.Add("axisCrossingValue", axis.AxisCrossingValues, () => axis.AxisCrossingValues.Count() > 0)
.Add("min", axis.Min.ToJavaScriptString(), () => axis.Min != null)
.Add("max", axis.Max.ToJavaScriptString(), () => axis.Max != null)
.Add("roundToBaseUnit", axis.RoundToBaseUnit, () => axis.RoundToBaseUnit.HasValue)
.Add("weekStartDay", (int?)axis.WeekStartDay, () => axis.WeekStartDay.HasValue)
.Add("justified", axis.Justified, () => axis.Justified.HasValue)
.Add("maxDateGroups", axis.MaxDateGroups, () => axis.MaxDateGroups.HasValue);
if (axis.BaseUnit != null)
{
result.Add("baseUnit", axis.BaseUnit.ToString().ToLowerInvariant());
}
if (axis.BaseUnitStep.HasValue)
{
if (axis.BaseUnitStep > 0)
{
result.Add("baseUnitStep", axis.BaseUnitStep);
}
else
{
result.Add("baseUnitStep", "auto");
}
}
if (axis.Categories != null)
{
result.Add("categories", SerializeCategories());
}
var autoBaseUnits = axis.AutoBaseUnitSteps.CreateSerializer().Serialize();
if (autoBaseUnits.Count > 0)
{
result.Add("autoBaseUnitSteps", autoBaseUnits);
}
var selectData = axis.Select.CreateSerializer().Serialize();
if (selectData.Count > 0)
{
result.Add("select", selectData);
}
var notes = axis.Notes.CreateSerializer().Serialize();
if (notes.Count > 0)
{
result.Add("notes", notes);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", "line")
.Add("stack", series.Stacked, false)
.Add("field", series.Member, () => { return(series.Data == null && series.Member != null); })
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("width", series.Width, ChartDefaults.LineSeries.Width)
.Add("color", series.Color, string.Empty)
.Add("dashType", series.DashType.ToString().ToLowerInvariant(), ChartDefaults.LineSeries.DashType.ToString().ToLowerInvariant())
.Add("missingValues", series.MissingValues.ToString().ToLowerInvariant(),
ChartDefaults.LineSeries.MissingValues.ToString().ToLowerInvariant());
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
var markers = series.Markers.CreateSerializer().Serialize();
if (markers.Count > 0)
{
result.Add("markers", markers);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
result["type"] = "bubble";
FluentDictionary.For(result)
.Add("sizeField", series.SizeMember, () => { return(series.Data == null && series.SizeMember != null); })
.Add("colorField", series.ColorMember, () => { return(series.Data == null && series.ColorMember != null); })
.Add("categoryField", series.CategoryMember, () => { return(series.Data == null && series.CategoryMember != null); })
.Add("visibleInLegendField", series.VisibleInLegendMember, () => { return(series.Data == null && series.VisibleInLegendMember != null); })
.Add("minSize", series.MinSize, () => series.MinSize.HasValue)
.Add("maxSize", series.MaxSize, () => series.MaxSize.HasValue);
var negativeValuesData = series.NegativeValues.CreateSerializer().Serialize();
if (negativeValuesData.Count > 0)
{
result.Add("negativeValues", negativeValuesData);
}
var borderData = series.Border.CreateSerializer().Serialize();
if (borderData.Count > 0)
{
result.Add("border", borderData);
}
return(result);
}
public async IAsyncEnumerable <TimesheetEntry> ListAsync(int?clientId, int?projectId, DateTime?startDate, DateTime?endDate, int?userId)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
int currentPage = 1;
FluentDictionary.For(parameters)
.Add("client_id", clientId, () => clientId.HasValue)
.Add("project_id", projectId, () => projectId.HasValue)
.Add("user_id", userId, () => userId.HasValue)
.Add("from", startDate?.ToString("yyyy-MM-dd"), () => startDate.HasValue)
.Add("to", endDate?.ToString("yyyy-MM-dd"), () => endDate.HasValue)
.Add("page", currentPage);;
var collection = await ProcessRequest <TimeEntryCollection>("time_entries", Method.GET, parameters);
while (collection.TotalPages >= currentPage)
{
foreach (var project in collection.TimeEntries)
{
yield return(project);
}
parameters["page"] = ++currentPage;
collection = await ProcessRequest <TimeEntryCollection>("time_entries", Method.GET, parameters);
}
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", "scatter")
.Add("xField", series.XMember, () => { return(series.Data == null && series.XMember != null); })
.Add("yField", series.YMember, () => { return(series.Data == null && series.YMember != null); })
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("xAxis", series.XAxis, () => !string.IsNullOrEmpty(series.XAxis))
.Add("yAxis", series.YAxis, () => !string.IsNullOrEmpty(series.YAxis))
.Add("color", series.Color, string.Empty);
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
var markers = series.Markers.CreateSerializer().Serialize();
if (markers.Count > 0)
{
result.Add("markers", markers);
}
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("type", series.Orientation == ChartSeriesOrientation.Horizontal ? "bar" : "column")
.Add("stack", series.Stacked, () => series.Stacked == true && !series.StackName.HasValue())
.Add("stack", series.StackName, () => series.StackName.HasValue())
.Add("aggregate", series.Aggregate.ToString().ToLowerInvariant(), () => series.Aggregate != null)
.Add("gap", series.Gap, () => series.Gap.HasValue)
.Add("spacing", series.Spacing, () => series.Spacing.HasValue)
.Add("field", series.Member, () => { return(series.Data == null && series.Member != null); })
.Add("data", series.Data, () => { return(series.Data != null); })
.Add("border", series.Border.CreateSerializer().Serialize(), ShouldSerializeBorder)
.Add("color", series.Color, () => series.Color.HasValue())
.Add("colorField", series.ColorMember, () => series.ColorMember.HasValue())
.Add("negativeColor", series.NegativeColor, () => series.NegativeColor.HasValue());
if (series.Overlay != null)
{
result.Add("overlay", series.Overlay.CreateSerializer().Serialize());
}
var labelsData = series.Labels.CreateSerializer().Serialize();
if (labelsData.Count > 0)
{
result.Add("labels", labelsData);
}
return(result);
}
protected override void Serialize(IDictionary <string, object> json)
{
if (!this.FunctionData.HasValue())
{
FluentDictionary.For(json).Add <string>("data", this.Data, string.Empty);
}
else
{
json.Add("data", this.FunctionData);
}
if (!this.FunctionTotal.HasValue())
{
FluentDictionary.For(json).Add <string>("total", this.Total, string.Empty);
}
else
{
json.Add("total", this.FunctionTotal);
}
if (!this.FunctionErrors.HasValue())
{
FluentDictionary.For(json).Add <string>("errors", this.Errors, string.Empty);
}
else
{
json.Add("errors", this.FunctionErrors);
}
if (!this.FunctionAggregates.HasValue())
{
FluentDictionary.For(json).Add <string>("aggregates", this.Aggregates, string.Empty);
}
else
{
json.Add("aggregates", this.FunctionAggregates);
}
if (!this.FunctionGroups.HasValue())
{
FluentDictionary.For(json).Add <string>("groups", this.Groups, string.Empty);
}
else
{
json.Add("groups", this.FunctionGroups);
}
if (this.FunctionModel != null)
{
json.Add("model", this.FunctionModel);
}
else if (this.Model != null)
{
json.Add("model", this.Model.ToJson());
}
if (!string.IsNullOrEmpty(this.Type))
{
json.Add("type", this.Type);
}
if (this.Parse.HasValue())
{
json.Add("parse", this.Parse);
}
}
public SimpleQueryStringQueryDescriptor <T> OnFieldsWithBoost(Action <FluentDictionary <string, double?> > boostableSelector)
{
var d = new FluentDictionary <string, double?>();
boostableSelector(d);
((ISimpleQueryStringQuery)this).Fields = d.Select(o => PropertyPathMarker.Create(o.Key, o.Value));
return(this);
}
public MultiMatchQueryDescriptor <T> OnFieldsWithBoost(Action <FluentDictionary <Expression <Func <T, object> >, double?> > boostableSelector)
{
var d = new FluentDictionary <Expression <Func <T, object> >, double?>();
boostableSelector(d);
((IMultiMatchQuery)this).Fields = d.Select(o => PropertyPathMarker.Create(o.Key, o.Value));
return(this);
}
public virtual IDictionary <string, object> Serialize()
{
var barData = seriesDefaults.Bar.CreateSerializer().Serialize();
barData.Remove("type");
var columnData = seriesDefaults.Column.CreateSerializer().Serialize();
columnData.Remove("type");
var lineData = seriesDefaults.Line.CreateSerializer().Serialize();
lineData.Remove("type");
var verticalLineData = seriesDefaults.VerticalLine.CreateSerializer().Serialize();
verticalLineData.Remove("type");
var areaData = seriesDefaults.Area.CreateSerializer().Serialize();
areaData.Remove("type");
var verticalAreaData = seriesDefaults.VerticalArea.CreateSerializer().Serialize();
verticalAreaData.Remove("type");
var pieData = seriesDefaults.Pie.CreateSerializer().Serialize();
pieData.Remove("type");
var scatterData = seriesDefaults.Scatter.CreateSerializer().Serialize();
scatterData.Remove("type");
var scatterLineData = seriesDefaults.ScatterLine.CreateSerializer().Serialize();
scatterLineData.Remove("type");
var ohlcData = seriesDefaults.OHLC.CreateSerializer().Serialize();
ohlcData.Remove("type");
var result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("bar", barData, () => barData.Count > 0)
.Add("column", columnData, () => columnData.Count > 0)
.Add("line", lineData, () => lineData.Count > 0)
.Add("verticalLine", verticalLineData, () => verticalLineData.Count > 0)
.Add("area", areaData, () => areaData.Count > 0)
.Add("verticalArea", verticalAreaData, () => verticalAreaData.Count > 0)
.Add("pie", pieData, () => pieData.Count > 0)
.Add("scatter", scatterData, () => scatterData.Count > 0)
.Add("scatterLine", scatterLineData, () => scatterLineData.Count > 0)
.Add("ohlc", ohlcData, () => ohlcData.Count > 0);
return(result);
}
protected override void Serialize(IDictionary <string, object> json)
{
if (Id != null)
{
json["id"] = Id.Name;
}
FluentDictionary.For(json)
.Add("hasChildren", HasChildrenMember, HasChildrenMember.HasValue);
if (ChildrenDataSource != null)
{
json["children"] = ChildrenDataSource.ToJson();
}
else if (ChildrenMember.HasValue())
{
json["children"] = ChildrenMember;
}
if (Fields.Count > 0)
{
var fields = new Dictionary <string, object>();
json["fields"] = fields;
Fields.Each(prop =>
{
var field = new Dictionary <string, object>();
fields[prop.Member] = field;
if (!prop.IsEditable)
{
field["editable"] = false;
}
field["type"] = prop.MemberType.ToJavaScriptType().ToLowerInvariant();
if (prop.MemberType.IsNullableType() || prop.DefaultValue != null)
{
field["defaultValue"] = prop.DefaultValue;
}
if (!string.IsNullOrEmpty(prop.From))
{
field["from"] = prop.From;
}
if (prop.IsNullable)
{
field["nullable"] = prop.IsNullable;
}
if (prop.Parse.HasValue())
{
field["parse"] = prop.Parse;
}
});
}
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("shared", chartTooltip.Shared, () => chartTooltip.Shared.HasValue);
return(result);
}
public virtual IDictionary <string, object> Serialize()
{
var result = new Dictionary <string, object>();
FluentDictionary.For(result)
.Add("gradient", overlay.Gradient.ToString().ToLowerInvariant());
return(result);
}
public SimilarityDescriptor CustomSimilarities(
Func<FluentDictionary<string, SimilarityBase>, FluentDictionary<string, SimilarityBase>> similaritySelector)
{
similaritySelector.ThrowIfNull("similaritySelector");
var similarities = new FluentDictionary<string, SimilarityBase>(this._SimilaritySettings.CustomSimilarities);
var newSimilarities = similaritySelector(similarities);
this._SimilaritySettings.CustomSimilarities = newSimilarities;
return this;
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("position", labels.Position.ToString().ToLowerInvariant(), () => labels.Position.HasValue);
return(result);
}
public override IDictionary <string, object> Serialize()
{
var result = base.Serialize();
FluentDictionary.For(result)
.Add("style", line.Style.ToString().ToLowerInvariant(), ChartAreaStyle.Normal.ToString().ToLowerInvariant());
return(result);
}
public AnalysisDescriptor Analyzers(
Func<FluentDictionary<string, AnalyzerBase>, FluentDictionary<string, AnalyzerBase>> analyzerSelector)
{
analyzerSelector.ThrowIfNull("analyzerSelector");
var analyzers = new FluentDictionary<string, AnalyzerBase>(this._AnalysisSettings.Analyzers);
var newAnalyzers = analyzerSelector(analyzers);
this._AnalysisSettings.Analyzers = newAnalyzers;
return this;
}
public AnalysisDescriptor CharFilters(
Func<FluentDictionary<string, CharFilterBase>, FluentDictionary<string, CharFilterBase>> charFiltersSelecter)
{
charFiltersSelecter.ThrowIfNull("charFiltersSelecter");
var charFilters = new FluentDictionary<string, CharFilterBase>(this._AnalysisSettings.CharFilters);
var newCharFilters = charFiltersSelecter(charFilters);
this._AnalysisSettings.CharFilters = newCharFilters;
return this;
}
public AnalysisDescriptor Tokenizers(
Func<FluentDictionary<string, TokenizerBase>, FluentDictionary<string, TokenizerBase>> tokenizerSelector)
{
tokenizerSelector.ThrowIfNull("tokenizerSelector");
var tokenizers = new FluentDictionary<string, TokenizerBase>(this._AnalysisSettings.Tokenizers);
var newTokenizers = tokenizerSelector(tokenizers);
this._AnalysisSettings.Tokenizers = newTokenizers;
return this;
}
private IEnumerable<KeyValuePair<string, int>> CodiciResto()
{
var tabellaConversione = new FluentDictionary<string, int>();
var i = 0;
Enumerable
.Range('A', 'Z' - 'A' + 1)
.ForEach(x => tabellaConversione.Entry(((char)x).ToInvariant(), i++));
return tabellaConversione;
}
/// <summary>
/// Instantiate a connectionsettings object to tell the client where and how to connect to elasticsearch
/// using a proxy
/// </summary>
/// <param name="uri">A Uri to describe the elasticsearch endpoint</param>
/// <param name="timeout">time out in milliseconds</param>
/// <param name="proxyAddress">proxy address</param>
/// <param name="username">proxy username</param>
/// <param name="password">proxy password</param>
public ConnectionSettings(Uri uri, int timeout, string proxyAddress, string username, string password)
{
uri.ThrowIfNull("uri");
this._uri = uri;
this._password = password;
this._username = username;
this._timeout = timeout;
this._proxyAddress = proxyAddress;
this.MaximumAsyncConnections = 20;
this._defaultTypeIndices = new FluentDictionary<Type, string>();
}
/// <summary>
/// Instantiate a connectionsettings object to tell the client where and how to connect to elasticsearch
/// </summary>
/// <param name="host">host (sans http(s)://), use the Uri constructor overload for more control</param>
/// <param name="port">port of the host (elasticsearch defaults on 9200)</param>
/// <param name="timeout">time out in milliseconds</param>
/// <param name="proxyAddress">proxy address</param>
/// <param name="username">proxy username</param>
/// <param name="password">proxy password</param>
public ConnectionSettings(string host, int port, int timeout, string proxyAddress, string username, string password)
{
host.ThrowIfNullOrEmpty("host");
var uri = new Uri("http://" + host + ":" + port);
this._host = host;
this._password = password;
this._username = username;
this._timeout = timeout;
this._port = port;
this._proxyAddress = proxyAddress;
this.MaximumAsyncConnections = 20;
this._defaultTypeIndices = new FluentDictionary<Type, string>();
}
