private void SerializeDataPoint(IBsonWriter writer, IDictionary <string, DataPoint> points)
{
foreach (var dp in points)
{
writer.WriteStartDocument(dp.Key);
if (!string.IsNullOrEmpty(dp.Value.Unit))
{
writer.WriteString("Unit", dp.Value.Unit);
}
if (dp.Value.Precision != null)
{
writer.WriteDouble("Precision", dp.Value.Precision.Value);
}
if (dp.Value.Accuracy != null)
{
writer.WriteDouble("Accuracy", dp.Value.Accuracy.Value);
}
writer.WriteDecimal128("Value", dp.Value.Value.ToDecimal128());
writer.WriteEndDocument();
}
}
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TimeSpan value)
{
IBsonWriter writer = context.Writer;
var bsonDouble = new BsonDouble(((TimeSpan)value).TotalMilliseconds);
writer.WriteDouble(bsonDouble.Value);
}
private void GenerateBsonValue(IBsonWriter writer, JToken value)
{
if (value != null)
{
switch (value.Type)
{
case JTokenType.Undefined:
writer.WriteUndefined();
return;
case JTokenType.Null:
case JTokenType.None:
writer.WriteNull();
return;
case JTokenType.Object:
GenerateBsonDocument(writer, value);
return;
case JTokenType.Array:
GenerateBsonArray(writer, value);
return;
case JTokenType.Integer:
writer.WriteInt32(value.Value <int>());
return;
case JTokenType.Float:
writer.WriteDouble(value.Value <double>());
return;
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.Raw:
case JTokenType.Date:
case JTokenType.Constructor:
case JTokenType.Property:
case JTokenType.Comment:
case JTokenType.String:
writer.WriteString(value.Value <string>());
return;
case JTokenType.Boolean:
writer.WriteBoolean(value.Value <bool>());
return;
case JTokenType.Bytes:
writer.WriteBytes(value.Value <byte[]>());
return;
case JTokenType.TimeSpan:
writer.WriteInt64(value.Value <long>());
return;
default:
break;
}
}
writer.WriteNull();
}
private void WriteValue(IBsonWriter writer, object value)
{
writer.WriteName("Value");
switch (value)
{
case int _int:
writer.WriteInt32(_int);
break;
case double _double:
writer.WriteDouble(_double);
break;
case string _string:
writer.WriteString(_string);
break;
case Entity _entity:
writer.WriteString(value.GetType().Name);
break;
default:
writer.WriteString("Could not find type");
break;
}
}
public override void Serialize(IBsonWriter bsonWriter, Amortization amort)
{
bsonWriter.WriteStartDocument();
bsonWriter.Write("_id", amort.ID);
bsonWriter.Write("user", amort.User);
bsonWriter.Write("name", amort.Name);
bsonWriter.Write("value", amort.Value);
bsonWriter.Write("date", amort.Date);
bsonWriter.Write("tday", amort.TotalDays);
switch (amort.Interval)
{
case AmortizeInterval.EveryDay:
bsonWriter.Write("interval", "d");
break;
case AmortizeInterval.SameDayOfWeek:
bsonWriter.Write("interval", "w");
break;
case AmortizeInterval.LastDayOfWeek:
bsonWriter.Write("interval", "W");
break;
case AmortizeInterval.SameDayOfMonth:
bsonWriter.Write("interval", "m");
break;
case AmortizeInterval.LastDayOfMonth:
bsonWriter.Write("interval", "M");
break;
case AmortizeInterval.SameDayOfYear:
bsonWriter.Write("interval", "y");
break;
case AmortizeInterval.LastDayOfYear:
bsonWriter.Write("interval", "Y");
break;
}
if (amort.Template != null)
{
bsonWriter.WriteName("template");
VoucherSerializer.Serialize(bsonWriter, amort.Template);
}
if (amort.Schedule != null)
{
bsonWriter.WriteStartArray("schedule");
foreach (var item in amort.Schedule)
{
ItemSerializer.Serialize(bsonWriter, item);
}
bsonWriter.WriteEndArray();
}
bsonWriter.Write("remark", amort.Remark);
bsonWriter.WriteEndDocument();
}
public override void Serialize(IBsonWriter bsonWriter, AssetItem item)
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteObjectId("voucher", item.VoucherID);
bsonWriter.Write("date", item.Date);
bsonWriter.Write("remark", item.Remark);
if (item is AcquisationItem acq)
{
bsonWriter.Write("acq", acq.OrigValue);
}
else if (item is DepreciateItem dep)
{
bsonWriter.Write("dep", dep.Amount);
}
else if (item is DevalueItem dev)
{
bsonWriter.Write("devto", dev.FairValue);
}
else if (item is DispositionItem)
{
bsonWriter.WriteNull("dispo");
}
bsonWriter.WriteEndDocument();
}
public override void Serialize(IBsonWriter bsonWriter, AssetItem item)
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteObjectId("voucher", item.VoucherID);
bsonWriter.Write("date", item.Date);
bsonWriter.Write("remark", item.Remark);
switch (item)
{
case AcquisitionItem acq:
bsonWriter.Write("acq", acq.OrigValue);
break;
case DepreciateItem dep:
bsonWriter.Write("dep", dep.Amount);
break;
case DevalueItem dev:
bsonWriter.Write("devto", dev.FairValue);
break;
case DispositionItem:
bsonWriter.WriteNull("dispo");
break;
}
bsonWriter.WriteEndDocument();
}
// constructors
private BsonSerializationContext(
IBsonWriter writer,
Func<Type, bool> isDynamicType)
{
_writer = writer;
_isDynamicType = isDynamicType;
}
// constructors
private BsonSerializationContext(
IBsonWriter writer,
Func <Type, bool> isDynamicType)
{
_writer = writer;
_isDynamicType = isDynamicType;
}
public void Serialize(BsonSerializationContext context, BsonSerializationArgs args, FieldValueChange value)
{
if (value.OriginalValue == null || value.NewValue == null)
{
object objectValue = value.OriginalValue ?? value.NewValue;
//if (objectValue != null)
//{
// IBsonSerializer serializer = BsonSerializer.LookupSerializer(objectValue.GetType());
// serializer.Serialize(context, args, objectValue);
//}
base.Serialize(context, args, objectValue);
}
else
{
IBsonWriter writer = context.Writer;
writer.WriteStartDocument();
writer.WriteName(nameof(value.OriginalValue));
IBsonSerializer serializer = BsonSerializer.LookupSerializer(value.OriginalValue.GetType());
serializer.Serialize(context, args, value.OriginalValue);
writer.WriteName(nameof(value.NewValue));
serializer = BsonSerializer.LookupSerializer(value.NewValue.GetType());
serializer.Serialize(context, args, value.NewValue);
writer.WriteEndDocument();
}
}
public override void Serialize(IBsonWriter bsonWriter, Asset asset)
{
bsonWriter.WriteStartDocument();
bsonWriter.Write("_id", asset.ID);
bsonWriter.Write("user", asset.User);
bsonWriter.Write("name", asset.Name);
bsonWriter.Write("date", asset.Date);
bsonWriter.Write("currency", asset.Currency);
bsonWriter.Write("value", asset.Value);
bsonWriter.Write("salvage", asset.Salvage);
bsonWriter.Write("life", asset.Life);
bsonWriter.Write("title", asset.Title);
bsonWriter.Write("deptitle", asset.DepreciationTitle);
bsonWriter.Write("devtitle", asset.DevaluationTitle);
bsonWriter.Write(
"exptitle",
asset.DepreciationExpenseSubTitle.HasValue
? asset.DepreciationExpenseTitle * 100 + asset.DepreciationExpenseSubTitle
: asset.DepreciationExpenseTitle);
bsonWriter.Write(
"exvtitle",
asset.DevaluationExpenseSubTitle.HasValue
? asset.DevaluationExpenseTitle * 100 + asset.DevaluationExpenseSubTitle
: asset.DevaluationExpenseTitle);
if (asset.Method != DepreciationMethod.None)
{
bsonWriter.Write("method", asset.Method switch
{
DepreciationMethod.StraightLine => ("sl"),
DepreciationMethod.SumOfTheYear => ("sy"),
DepreciationMethod.DoubleDeclineMethod => ("dd"),
_ => throw new InvalidOperationException(),
});
/// <summary>
/// Serializes the provide <paramref name="value"/> as a set of key/value pairs.
/// </summary>
/// <param name="context">The serialisation context.</param>
/// <param name="args">The serialisation arguments.</param>
/// <param name="value">The value.</param>
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TStruct value)
{
Type nominalType = args.NominalType;
FieldInfo[] fields = nominalType.GetFields(BindingFlags.Instance | BindingFlags.Public);
PropertyInfo[] propsAll = nominalType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
IEnumerable <PropertyInfo> props = propsAll.Where(prop => prop.CanWrite).ToList();
IBsonWriter bsonWriter = context.Writer;
bsonWriter.WriteStartDocument();
foreach (FieldInfo field in fields)
{
bsonWriter.WriteName(field.Name);
BsonSerializer.Serialize(bsonWriter, field.FieldType, field.GetValue(value));
}
foreach (PropertyInfo prop in props)
{
bsonWriter.WriteName(prop.Name);
BsonSerializer.Serialize(bsonWriter, prop.PropertyType, prop.GetValue(value, null));
}
bsonWriter.WriteEndDocument();
}
/***************************************************/
public static void AddVersion(this IBsonWriter writer)
{
if (writer != null)
{
writer.WriteName("_bhomVersion");
writer.WriteString(Reflection.Query.BHoMVersion());
}
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="WrappingBsonWriter"/> class.
/// </summary>
/// <param name="wrapped">The wrapped writer.</param>
public WrappingBsonWriter(IBsonWriter wrapped)
{
if (wrapped == null)
{
throw new ArgumentNullException(nameof(wrapped));
}
_wrapped = wrapped;
}
// constructors
public BsonWriterAdapter(
IBsonWriter wrappedWriter,
IPropertyNamesAdapter propertyNameBinder = null
)
{
_wrappedWriter = wrappedWriter;
_propertyNameBinder = propertyNameBinder;
}
internal static void WriteReference(this IBsonWriter writer, EntityReference value)
{
writer.WriteName("_name");
writer.WriteString(value.LogicalName);
writer.WriteName("_id");
writer.WriteBinaryData(new BsonBinaryData(value.Id));
}
private void WriteType0Section(IBsonWriter writer, Type0CommandMessageSection section)
{
writer.WriteName("document");
var serializer = section.DocumentSerializer;
var context = BsonSerializationContext.CreateRoot(writer);
serializer.Serialize(context, section.Document);
}
private void SerializeCollectionNamespace(IBsonWriter writer, CollectionNamespace value)
{
writer.WriteStartDocument();
writer.WriteName("db");
writer.WriteString(value.DatabaseNamespace.DatabaseName);
writer.WriteName("coll");
writer.WriteString(value.CollectionName);
writer.WriteEndDocument();
}
private void WriteSections(IBsonWriter writer, IEnumerable <CommandMessageSection> sections)
{
writer.WriteStartArray();
foreach (var section in sections)
{
WriteSection(writer, section);
}
writer.WriteEndArray();
}
public override void Serialize(IBsonWriter bsonWriter, AmortItem item)
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteObjectId("voucher", item.VoucherID);
bsonWriter.Write("date", item.Date);
bsonWriter.Write("amount", item.Amount);
bsonWriter.Write("remark", item.Remark);
bsonWriter.WriteEndDocument();
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <typeparam name="TNominalType">The nominal type of the object.</typeparam>
/// <param name="bsonWriter">The BsonWriter.</param>
/// <param name="value">The object.</param>
/// <param name="configurator">The serialization context configurator.</param>
public static void Serialize <TNominalType>(
IBsonWriter bsonWriter,
TNominalType value,
Action <BsonSerializationContext.Builder> configurator = null)
{
var serializer = LookupSerializer <TNominalType>();
var context = BsonSerializationContext.CreateRoot <TNominalType>(bsonWriter, configurator);
serializer.Serialize(context, value);
}
/// <summary>
/// 安全地写入<c>string</c>类型的字段
/// </summary>
/// <param name="bsonWriter">Bson读取器</param>
/// <param name="name">字段名</param>
/// <param name="value">字段值</param>
/// <param name="force">是否强制写入<c>null</c>值</param>
public static void Write(this IBsonWriter bsonWriter, string name, string value, bool force = false)
{
if (value != null)
{
bsonWriter.WriteString(name, value);
}
else if (force)
{
bsonWriter.WriteNull(name);
}
}
/// <summary>
/// 安全地写入<c>DateTime</c>类型的字段
/// </summary>
/// <param name="bsonWriter">Bson读取器</param>
/// <param name="name">字段名</param>
/// <param name="value">字段值</param>
/// <param name="force">是否强制写入<c>null</c>值</param>
public static void Write(this IBsonWriter bsonWriter, string name, DateTime?value, bool force = false)
{
if (value.HasValue)
{
bsonWriter.WriteDateTime(name, BsonUtils.ToMillisecondsSinceEpoch(value.Value));
}
else if (force)
{
bsonWriter.WriteNull(name);
}
}
/// <summary>
/// 安全地写入<c>double</c>类型的字段
/// </summary>
/// <param name="bsonWriter">Bson读取器</param>
/// <param name="name">字段名</param>
/// <param name="value">字段值</param>
/// <param name="force">是否强制写入<c>null</c>值</param>
public static void Write(this IBsonWriter bsonWriter, string name, double?value, bool force = false)
{
if (value.HasValue)
{
bsonWriter.WriteDouble(name, value.Value);
}
else if (force)
{
bsonWriter.WriteNull(name);
}
}
/// <summary>
/// 安全地写入<c>Guid</c>类型的字段
/// </summary>
/// <param name="bsonWriter">Bson读取器</param>
/// <param name="name">字段名</param>
/// <param name="value">字段值</param>
/// <param name="force">是否强制写入<c>null</c>值</param>
public static void Write(this IBsonWriter bsonWriter, string name, Guid?value, bool force = false)
{
if (value.HasValue)
{
bsonWriter.WriteBinaryData(name, value.Value.ToBsonValue());
}
else if (force)
{
bsonWriter.WriteNull(name);
}
}
/// <summary>
/// 安全地写入<c>ObjectId</c>类型的字段
/// </summary>
/// <param name="bsonWriter">Bson读取器</param>
/// <param name="name">字段名</param>
/// <param name="value">字段值</param>
/// <param name="force">是否强制写入<c>null</c>值</param>
public static void WriteObjectId(this IBsonWriter bsonWriter, string name, string value, bool force = false)
{
if (value != null)
{
bsonWriter.WriteObjectId(name, ObjectId.Parse(value));
}
else if (force)
{
bsonWriter.WriteNull(name);
}
}
/// <summary>
/// Serializes an object to a binary destination.
/// </summary>
/// <param name="Writer">Binary destination.</param>
/// <param name="WriteTypeCode">If a type code is to be output.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <param name="Value">The actual object to serialize.</param>
public void Serialize(IBsonWriter Writer, bool WriteTypeCode, bool Embedded, object Value)
{
if (Value is null)
{
Writer.WriteNull();
}
else
{
Writer.WriteBytes((byte[])Value);
}
}
/// <summary>
/// Serializes an object to a binary destination.
/// </summary>
/// <param name="Writer">Binary destination.</param>
/// <param name="WriteTypeCode">If a type code is to be output.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <param name="Value">The actual object to serialize.</param>
public override void Serialize(IBsonWriter Writer, bool WriteTypeCode, bool Embedded, object Value)
{
if (this.asInt)
{
Writer.WriteInt32((int)Value);
}
else
{
Writer.WriteString(Value.ToString());
}
}
// public static methods
/// <summary>
/// Creates a root context.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="configurator">The serialization context configurator.</param>
/// <returns>
/// A root context.
/// </returns>
public static BsonSerializationContext CreateRoot(
IBsonWriter writer,
Action<Builder> configurator = null)
{
var builder = new Builder(null, writer);
if (configurator != null)
{
configurator(builder);
}
return builder.Build();
}
private void SerializeMember(BsonSerializationContext context, TClass document, BsonMemberMap memberMap)
{
IBsonWriter bsonWriter = context.Writer;
object value = memberMap.Getter(document);
if (memberMap.ShouldSerialize(document, value))
{
bsonWriter.WriteName(memberMap.ElementName);
memberMap.GetSerializer().Serialize(context, value);
}
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="bsonWriter">The BsonWriter.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="value">The object.</param>
/// <param name="configurator">The serialization context configurator.</param>
public static void Serialize(
IBsonWriter bsonWriter,
Type nominalType,
object value,
Action <BsonSerializationContext.Builder> configurator = null)
{
var serializer = LookupSerializer(nominalType);
var context = BsonSerializationContext.CreateRoot(bsonWriter, nominalType, configurator);
serializer.Serialize(context, value);
}
/// <summary>
/// Serializes an object to a binary destination.
/// </summary>
/// <param name="Writer">Binary destination.</param>
/// <param name="WriteTypeCode">If a type code is to be output.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <param name="Value">The actual object to serialize.</param>
public override void Serialize(IBsonWriter Writer, bool WriteTypeCode, bool Embedded, object Value)
{
if (Value is null)
{
Writer.WriteNull();
}
else
{
Writer.WriteString(((Enum)this.valueProperty.GetMethod.Invoke(Value, null)).ToString());
}
}
// constructors
public JsonWriterAdapter(IBsonWriter wrappedWriter)
{
_wrappedWriter = wrappedWriter;
}
// constructors
internal Builder(BsonSerializationContext other, IBsonWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
_writer = writer;
if (other != null)
{
_isDynamicType = other._isDynamicType;
}
else
{
_isDynamicType = t =>
(BsonDefaults.DynamicArraySerializer != null && t == BsonDefaults.DynamicArraySerializer.ValueType) ||
(BsonDefaults.DynamicDocumentSerializer != null && t == BsonDefaults.DynamicDocumentSerializer.ValueType);
}
}
