public SchemaScope(JTokenType tokenType, IList<JsonSchemaModel> schemas)
{
_tokenType = tokenType;
_schemas = schemas;
_requiredProperties = schemas.SelectMany<JsonSchemaModel, string>(GetRequiredProperties).Distinct().ToDictionary(p => p, p => false);
}
private ValidationResult ValidateMultiValue(string path, IMetadataDefinition definition, JToken token, JTokenType expectedType)
{
if (token.Type == JTokenType.Array)
{
var array = (JArray)token;
int index = 0;
foreach (var item in array)
{
if (item.Type != expectedType)
{
return ValidationResult.Fail(ValidationErrorCodes.WellknownMetadata.UnexpectedItemType, $"Bad metadata: unexpected type '{token.Type.ToString()}' for property {path}[{index}], expected type '{expectedType.ToString()}'.", path);
}
}
return ValidationResult.Success;
}
else if (token.Type == JTokenType.Null)
{
if (definition.IsRequired)
{
return ValidationResult.Fail(ValidationErrorCodes.WellknownMetadata.FieldRequired, $"Bad metadata: property {path} is required.", path);
}
return ValidationResult.Success;
}
return ValidationResult.Fail(ValidationErrorCodes.WellknownMetadata.UnexpectedType, $"Bad metadata: unexpected type '{token.Type.ToString()}' for property {path}, expected type '{nameof(JTokenType.Array)}'.", path);
}
public IEnumerable<JsonData> GetNext(JTokenType type)
{
foreach (var token in JsonObject.Children().Where(t => t.Type == type))
{
yield return new JsonData(token.ToString());
}
}
public SchemaScope(JTokenType tokenType, JsonSchemaModel schema)
{
_tokenType = tokenType;
_schema = schema;
if (_schema != null && _schema.Properties != null)
_requiredProperties = GetRequiredProperties(_schema).Distinct().ToDictionary(p => p, p => false);
else
_requiredProperties = new Dictionary<string, bool>();
}
public SchemaScope(JTokenType tokenType, IList<JsonSchemaModel> schemas)
{
_tokenType = tokenType;
_schemas = schemas;
_requiredProperties = schemas.SelectMany<JsonSchemaModel, string>(GetRequiredProperties).Distinct().ToDictionary(p => p, p => false);
if (tokenType == JTokenType.Array && schemas.Any(s => s.UniqueItems))
{
IsUniqueArray = true;
UniqueArrayItems = new List<JToken>();
}
}
private static bool Check(JToken jo, string key, JTokenType type, bool isNeedCheck)
{
if (!isNeedCheck) return true;
if (jo[key] == null)
{
System.Diagnostics.Debug.WriteLine(string.Format("Error: {0} is Null!", key));
return false;
}
if (jo[key].Type != type)
{
System.Diagnostics.Debug.WriteLine(string.Format("Error: {0} should be {1}, not {2}!", key, type, jo[key].Type));
return false;
}
return true;
}
private ValidationResult ValidateSimpleValue(string path, IMetadataDefinition definition, JToken token, JTokenType expectedType)
{
if (token.Type == expectedType)
{
return ValidationResult.Success;
}
if (token.Type == JTokenType.Null)
{
if (definition.IsRequired)
{
return ValidationResult.Fail(ValidationErrorCodes.WellknownMetadata.FieldRequired, $"Bad metadata: property {path} is required.", path);
}
return ValidationResult.Success;
}
return ValidationResult.Fail(ValidationErrorCodes.WellknownMetadata.UnexpectedType, $"Bad metadata: unexpected type '{token.Type.ToString()}' for property {path}, expected type '{expectedType.ToString()}'.", path);
}
public static DbType FromJsonType(JTokenType type)
{
if (type == JTokenType.String) {
return DbType.Varchar;
}
if (type == JTokenType.Float) {
return DbType.Float;
}
if (type == JTokenType.Integer) {
return DbType.Integer;
}
if (type == JTokenType.Date) {
return DbType.DateTime;
}
if (type == JTokenType.Boolean) {
return DbType.Bit;
}
return DbType.Unknown;
}
public static object SerializeValue(JToken value, string storeType, JTokenType columnType)
{
if (value == null || value.Type == JTokenType.Null)
{
return null;
}
if (IsTextType(storeType))
{
return SerializeAsText(value, columnType);
}
if (IsRealType(storeType))
{
return SerializeAsReal(value, columnType);
}
if (IsNumberType(storeType))
{
return SerializeAsNumber(value, columnType);
}
return value.ToString();
}
public static JToken DeserializeValue(object value, string storeType, JTokenType columnType)
{
if (value == null)
{
return null;
}
if (IsTextType(storeType))
{
return SqlHelpers.ParseText(columnType, value);
}
if (IsRealType(storeType))
{
return SqlHelpers.ParseReal(columnType, value);
}
if (IsNumberType(storeType))
{
return SqlHelpers.ParseNumber(columnType, value);
}
return null;
}
public static string GetColumnType(JTokenType type, bool allowNull)
{
switch (type)
{
case JTokenType.Boolean:
return SqlColumnType.Bit;
case JTokenType.Integer:
return SqlColumnType.BigInt;
case JTokenType.Date:
return SqlColumnType.DateTime;
case JTokenType.Float:
return SqlColumnType.Double;
case JTokenType.Guid:
return SqlColumnType.UniqueIdentifier;
case JTokenType.String:
case JTokenType.Array:
case JTokenType.Object:
return SqlColumnType.NVarcharMax;
case JTokenType.Bytes:
return SqlColumnType.VarBinaryMax;
case JTokenType.Null:
if (allowNull)
{
return null;
}
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.SqlStore_JTokenNotSupported, type));
case JTokenType.Comment:
case JTokenType.Constructor:
case JTokenType.None:
case JTokenType.Property:
case JTokenType.Raw:
case JTokenType.TimeSpan:
case JTokenType.Undefined:
case JTokenType.Uri:
default:
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.SqlStore_JTokenNotSupported, type));
}
}
/// <summary>
/// Gets the .NET type from JTokenType.
/// </summary>
/// <param name="jt">The JTokenType to convert</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException">support for + jt + is not implemented.</exception>
private static string GetTypeFromJTokenType(JTokenType jt)
{
switch (jt)
{
case JTokenType.TimeSpan:
case JTokenType.Uri:
case JTokenType.Boolean:
case JTokenType.Guid:
case JTokenType.String:
return jt.ToString();
case JTokenType.Bytes:
return "byte[]";
case JTokenType.Date:
return "DateTime";
case JTokenType.Float:
return "double";
case JTokenType.Integer:
return "int";
case JTokenType.Null:
return "String";
default:
throw new NotImplementedException("support for " + jt + " is not implemented.");
}
}
public ValuePanel(JTokenType _type, object _value)
{
this.AllowDrop = true;
this.HorizontalAlignment = HorizontalAlignment.Left;
this.VerticalAlignment = VerticalAlignment.Stretch;
this.Margin = new Thickness(JsonTreeViewItemSize.MARGIN_TEXTBOX);
this.Width = JsonTreeViewItemSize.WIDTH_VALUEPANEL;
this.Orientation = Orientation.Horizontal;
type = _type;
value = _value;
switch (type)
{
case JTokenType.Array:
break;
case JTokenType.Boolean:
//TextBlock tb_boolean = new TextBlock();
//tb_boolean.Text = value.ToString();
//tb_boolean.VerticalAlignment = VerticalAlignment.Center;
//tb_boolean.Background = null;
//CheckBox cb = new CheckBox();
//cb.IsChecked = (bool)value;
//this.Children.Add(cb);
//cb.Checked += delegate { tb_boolean.Text = cb.IsChecked.ToString(); this.value = cb.IsChecked; };
//cb.Unchecked += delegate { tb_boolean.Text = cb.IsChecked.ToString(); this.value = cb.IsChecked; };
//this.Children.Add(tb_boolean);
ToggleSwitch ts = new ToggleSwitch();
ts.IsChecked = (bool)value;
ts.Width = JsonTreeViewItemSize.WIDTH_TEXTBOX;
ts.FontSize = 13;
ts.OffLabel = "False";
ts.OnLabel = "True";
ts.Style = (Style)App.Current.Resources["MahApps.Metro.Styles.ToggleSwitch.Win10"];
ts.Checked += delegate { this.value = ts.IsChecked; };
ts.Unchecked += delegate { this.value = ts.IsChecked; };
this.Children.Add(ts);
break;
case JTokenType.Bytes:
break;
case JTokenType.Comment:
break;
case JTokenType.Constructor:
break;
case JTokenType.Date:
break;
case JTokenType.Float:
break;
case JTokenType.Guid:
break;
case JTokenType.Integer:
//ValueTextBox tb_integer = new ValueTextBox(value.ToString());
////tb_integer.Text = value.ToString();
////tb_integer.Width = this.Width;
//tb_integer.TextChanged += TextBox_TextChanged;
//this.Children.Add(tb_integer);
NumericUpDown tb_integer = new NumericUpDown();
tb_integer.Width = JsonTreeViewItemSize.WIDTH_TEXTBOX;
//Console.WriteLine("\t\tval = " + this.value.GetType());
tb_integer.Value = (System.Int64) this.value;
tb_integer.HorizontalContentAlignment = HorizontalAlignment.Left;
tb_integer.ValueChanged += delegate { this.value = (int)tb_integer.Value; };
this.Children.Add(tb_integer);
break;
case JTokenType.None:
break;
case JTokenType.Null:
break;
case JTokenType.Object:
break;
case JTokenType.Property:
break;
case JTokenType.Raw:
break;
case JTokenType.String:
ValueTextBox tb_string = new ValueTextBox(value.ToString());
//ValueTextBox tb_string = new ValueTextBox("\"" + value.ToString() + "\"");
//tb_string.Text = "\"" + value.ToString() + "\"";
tb_string.Width = JsonTreeViewItemSize.WIDTH_TEXTBOX;
tb_string.TextChanged += delegate { this.value = tb_string.Text; };
this.Children.Add(tb_string);
break;
case JTokenType.TimeSpan:
break;
case JTokenType.Undefined:
break;
case JTokenType.Uri:
break;
}
Label label = new Label();
label.VerticalAlignment = VerticalAlignment.Center;
label.Foreground = Brushes.Gray;
label.FontSize = 10;
label.Content = type.ToString();
this.Children.Add(label);
}
private static byte[] SerializeAsBytes(JToken value, JTokenType columnType)
{
if (columnType == JTokenType.Bytes && value.Type == JTokenType.Bytes)
{
return value.Value<byte[]>();
}
return null;
}
private static long SerializeAsInteger(JToken value, JTokenType columnType)
{
return value.Value<long>();
}
internal JValue(object value, JTokenType type)
{
_value = value;
_valueType = type;
}
private void AutoCompleteClose(JsonToken tokenBeingClosed)
{
// write closing symbol and calculate new state
int levelsToComplete = 0;
for (int i = 0; i < _top; i++)
{
int currentLevel = _top - i;
if (_stack[currentLevel] == GetTypeForCloseToken(tokenBeingClosed))
{
levelsToComplete = i + 1;
break;
}
}
if (levelsToComplete == 0)
{
throw new JsonWriterException("No token to close.");
}
for (int i = 0; i < levelsToComplete; i++)
{
JsonToken token = GetCloseTokenForType(Pop());
if (_formatting == Formatting.Indented)
{
if (_currentState != State.ObjectStart && _currentState != State.ArrayStart)
{
WriteIndent();
}
}
WriteEnd(token);
}
JTokenType currentLevelType = Peek();
switch (currentLevelType)
{
case JTokenType.Object:
_currentState = State.Object;
break;
case JTokenType.Array:
_currentState = State.Array;
break;
case JTokenType.Constructor:
_currentState = State.Array;
break;
case JTokenType.None:
_currentState = State.Start;
break;
default:
throw new JsonWriterException("Unknown JsonType: " + currentLevelType);
}
}
public SchemaScope(JTokenType tokenType, IList<JsonSchemaModel> schemas)
{
this._tokenType = tokenType;
this._schemas = schemas;
this._requiredProperties = Enumerable.ToDictionary<string, string, bool>(Enumerable.Distinct<string>(Enumerable.SelectMany<JsonSchemaModel, string>((IEnumerable<JsonSchemaModel>) schemas, new Func<JsonSchemaModel, IEnumerable<string>>(this.GetRequiredProperties))), (Func<string, string>) (p => p), (Func<string, bool>) (p => false));
}
private static long SerializeAsInteger(JToken value, JTokenType columnType)
{
return(value.Value <long>());
}
private void Push(JTokenType value)
{
_top++;
if (_stack.Count <= _top)
_stack.Add(value);
else
_stack[_top] = value;
}
private static string SerializeAsText(JToken value, JTokenType columnType)
{
return(value.ToString());
}
public DataProperty(string name, JTokenType type)
{
this.Name = name;
this.Type = DataProperty.GetTypeFromJTokenType(type);
}
public override Object ReadJson(JsonReader reader, Type objectType, Object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
{
return(null);
}
SpeciesFileDescription speciesFileDescription = new SpeciesFileDescription();
JObject rootObject = JObject.Load(reader);
if (rootObject == null)
{
return(null);
}
IList <SpeciesClassMapping> speciesClasses = new List <SpeciesClassMapping>();
foreach (JProperty classMapping in rootObject.Children <JProperty>())
{
if (classMapping.Value?.Type != JTokenType.Object)
{
continue;
}
SpeciesClassMapping speciesClass = new SpeciesClassMapping {
SpeciesClassName = classMapping.Name,
SpeciesClassSpeciesMappings = new List <SpeciesMapping>()
};
JObject classSpeciesMappings = (JObject)classMapping.Value;
foreach (JProperty speciesMapping in classSpeciesMappings.Children <JProperty>())
{
string speciesPath;
IEnumerable <string> speciesHints = null;
JTokenType tokenType = speciesMapping.Value.Type;
if (tokenType == JTokenType.Array)
{
JArray childArray = speciesMapping.Value as JArray;
if (childArray == null)
{
throw new InvalidOperationException("Could not convert property value to array.");
}
speciesPath = childArray.First.ToObject <string>();
speciesHints = childArray
.Skip(1)
.Select(t => t.ToObject <string>())
.ToList();
}
else if (tokenType == JTokenType.String)
{
speciesPath = speciesMapping.Value.ToObject <string>();
}
else
{
continue;
}
SpeciesMapping species = new SpeciesMapping {
SpeciesName = speciesMapping.Name,
SpeciesImageDirectory = speciesPath,
SpeciesHints = speciesHints?.ToList() ?? new List <String>()
};
speciesClass
.SpeciesClassSpeciesMappings
.Add(species);
}
if (speciesClass
.SpeciesClassSpeciesMappings
.Count == 0)
{
continue;
}
speciesClasses.Add(speciesClass);
}
speciesFileDescription.SpeciesClassMappings = speciesClasses;
return(speciesClasses.Count == 0 ? null : speciesFileDescription);
}
private static double SerializeAsReal(JToken value, JTokenType columnType)
{
return(value.Value <double>());
}
private static object SerializeAsNumber(JToken value, JTokenType columnType)
{
return(value.Value <long>());
}
public bool IsValid(string value, JTokenType tokenType)
{
return(WasCalled = true);
}
private JsonToken GetCloseTokenForType(JTokenType type)
{
switch (type)
{
case JTokenType.Object:
return JsonToken.EndObject;
case JTokenType.Array:
return JsonToken.EndArray;
case JTokenType.Constructor:
return JsonToken.EndConstructor;
default:
throw new JsonWriterException("No close token for type: " + type);
}
}
public static dynamic CastToStatic(JObject cfg)
{
// casts a JObject consisting of simple types (int, bool, string,
// float, and single dimensional arrays) to a C# expando object, obviating
// the need for casts to work in C# native types
dynamic settings = new ExpandoObject();
foreach (JProperty prop in cfg.Properties())
{
// convert from JObject types to .NET internal types
// and add to dynamic settings object
// if JSON contains arrays, we need to peek at the
// type of the contents to get the right cast, as
// C# doesn't implicitly cast the contents of an
// array when casing the array
if (prop.Value is Newtonsoft.Json.Linq.JArray)
{
JTokenType jType = JTokenType.None;
foreach (JToken child in prop.Value.Children())
{
if (jType == JTokenType.None)
{
jType = child.Type;
}
else if (jType != child.Type)
{
throw new Exception("Mixed type arrays not supported");
}
}
Type cType = JTypeConversion((int)jType);
if (cType == typeof(string))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <string[]>());
}
else if (cType == typeof(int))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <int[]>());
}
else if (cType == typeof(float))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <float[]>());
}
else if (cType == typeof(bool))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <bool[]>());
}
}
else
{
Type cType = JTypeConversion((int)prop.Value.Type);
if (cType == typeof(string))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <string>());
}
else if (cType == typeof(int))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <int>());
}
else if (cType == typeof(float))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <float>());
}
else if (cType == typeof(bool))
{
((IDictionary <string, object>)settings).Add(prop.Name, prop.Value.ToObject <bool>());
}
}
}
return(settings);
}
private static JTokenType GetStringValueType(JTokenType? current)
{
if (current == null)
return JTokenType.String;
switch (current.Value)
{
case JTokenType.Comment:
case JTokenType.String:
case JTokenType.Raw:
return current.Value;
default:
return JTokenType.String;
}
}
private void WrongJsonType(string name, JTokenType expected, JTokenType actual)
{
_redirector.WriteErrorLine(Strings.CookiecutterClient_WrongJsonType.FormatUI(name, expected, actual));
}
private JTokenType Pop()
{
JTokenType value = Peek();
_stack.RemoveAt(_stack.Count - 1);
_top--;
_currentTypeContext = _stack[_top - 1];
return value;
}
public Document Parse(string name, Stream readStream)
{
// PdfDocument pdf = PdfDocument.Open(readStream);
List <string> textList = new List <string>();
using (var pdf = PdfDocument.Open(readStream)) {
foreach (var page in pdf.GetPages())
{
var lines = ContentOrderTextExtractor.GetText(page, true)
.Split(GetLineSeparator()).Select(line => line.Trim())
.Where(line => !line.Equals(""));
textList.AddRange(lines);
}
}
string[] texts = textList.ToArray();
Document doc = new Document();
// Positional lookup for "relativeTo" rule
Dictionary <string, int> extractedPosition = new Dictionary <string, int>();
// Get configs
JObject lookup = GetConfig()["lookup"] as JObject;
if (lookup is null)
{
throw new Exception("Invalid parser config: lookup is null");
}
// Use a queue for iterating through properties, since some text extraction could depend on others
Queue <PropertyInfo> propQueue = new Queue <PropertyInfo>(Document.Properties);
while (propQueue.Count > 0)
{
PropertyInfo docProp = propQueue.Dequeue();
JToken config = lookup[docProp.Name];
if (config is null)
{
continue;
}
JTokenType configType = config.Type;
// Rules based on string matching
if (configType.Equals(JTokenType.Object))
{
JObject rules = config as JObject;
string target = null;
int targetPos = -1;
string value = "";
if (rules["index"] != null)
{
target = texts[(int)rules["index"]];
}
else if (rules["startsWith"] != null)
{
JToken startsWith = rules["startsWith"];
if (startsWith.Type == JTokenType.String)
{
(target, targetPos) = findLine(texts, (text => text.StartsWith((string)rules["startsWith"])));
}
else
{
string[] startsWithes = startsWith.ToObject <string[]>();
(target, targetPos) = findLine(texts, text => startsWithes.Any(query => text.StartsWith(query)));
}
}
else if (rules["indexOf"] != null)
{
targetPos = Array.IndexOf(texts, (string)rules["indexOf"]);
if (targetPos < 0)
{
continue;
}
target = texts[targetPos];
}
else if (rules["relativeTo"] != null)
{
targetPos = extractedPosition.GetValueOrDefault((string)rules["relativeTo"], -1);
// Relative Member not parsed yet, requeue for processing
if (targetPos == -1)
{
propQueue.Enqueue(docProp);
continue;
}
target = texts[targetPos];
}
// Allow user to find specific line relative to somone common string like "Total Due"
if (rules["offset"] != null)
{
targetPos += (int)rules["offset"];
target = texts[targetPos];
}
if (target is null)
{
continue;
}
extractedPosition.Add(docProp.Name, targetPos);
// Further extraction with regex if needed, select specific group of text
if (rules["regex"] != null)
{
string regexPattern = (string)rules["regex"];
Regex regex = new Regex(regexPattern);
Match matched = regex.Match(target);
int group = (int?)rules["group"] ?? 0;
value = matched.Groups[group].Value;
}
else
{
value = target;
}
docProp.SetValue(doc, serializeValue(value, docProp.PropertyType));
}
}
return(doc);
}
/// <summary>Validates format of given value.</summary>
/// <param name="value">String value.</param>
/// <param name="tokenType">Type of token holding the value.</param>
/// <returns>True if value is correct for given format, False - if not.</returns>
public bool IsValid(string value, JTokenType tokenType)
{
return(Regex.IsMatch(value, EmailRegexExpression, RegexOptions.IgnoreCase));
}
internal static int Compare(JTokenType valueType, object objA, object objB)
{
if (objA == null && objB == null)
{
return(0);
}
if (objA != null && objB == null)
{
return(1);
}
if (objA == null && objB != null)
{
return(-1);
}
switch (valueType)
{
case JTokenType.Comment:
case JTokenType.String:
case JTokenType.Raw:
return(string.CompareOrdinal(Convert.ToString(objA, (IFormatProvider)CultureInfo.InvariantCulture), Convert.ToString(objB, (IFormatProvider)CultureInfo.InvariantCulture)));
case JTokenType.Integer:
if (objA is ulong || objB is ulong || (objA is Decimal || objB is Decimal))
{
return(Convert.ToDecimal(objA, (IFormatProvider)CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, (IFormatProvider)CultureInfo.InvariantCulture)));
}
return(objA is float || objB is float || (objA is double || objB is double) ? JValue.CompareFloat(objA, objB) : Convert.ToInt64(objA, (IFormatProvider)CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(objB, (IFormatProvider)CultureInfo.InvariantCulture)));
case JTokenType.Float:
return(JValue.CompareFloat(objA, objB));
case JTokenType.Boolean:
return(Convert.ToBoolean(objA, (IFormatProvider)CultureInfo.InvariantCulture).CompareTo(Convert.ToBoolean(objB, (IFormatProvider)CultureInfo.InvariantCulture)));
case JTokenType.Date:
if (objA is DateTime dateTime)
{
DateTime dateTime = !(objB is DateTimeOffset dateTimeOffset2) ? Convert.ToDateTime(objB, (IFormatProvider)CultureInfo.InvariantCulture) : dateTimeOffset2.DateTime;
return(dateTime.CompareTo(dateTime));
}
DateTimeOffset dateTimeOffset1 = (DateTimeOffset)objA;
if (!(objB is DateTimeOffset other))
{
other = new DateTimeOffset(Convert.ToDateTime(objB, (IFormatProvider)CultureInfo.InvariantCulture));
}
return(dateTimeOffset1.CompareTo(other));
case JTokenType.Bytes:
if (!(objB is byte[]))
{
throw new ArgumentException("Object must be of type byte[].");
}
byte[] a1 = objA as byte[];
byte[] a2 = objB as byte[];
if (a1 == null)
{
return(-1);
}
return(a2 == null ? 1 : MiscellaneousUtils.ByteArrayCompare(a1, a2));
case JTokenType.Guid:
if (!(objB is Guid guid))
{
throw new ArgumentException("Object must be of type Guid.");
}
return(((Guid)objA).CompareTo(guid));
case JTokenType.Uri:
if ((object)(objB as Uri) == null)
{
throw new ArgumentException("Object must be of type Uri.");
}
return(Comparer <string> .Default.Compare(((Uri)objA).ToString(), ((Uri)objB).ToString()));
case JTokenType.TimeSpan:
if (!(objB is TimeSpan timeSpan))
{
throw new ArgumentException("Object must be of type TimeSpan.");
}
return(((TimeSpan)objA).CompareTo(timeSpan));
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(valueType), (object)valueType, "Unexpected value type: {0}".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)valueType));
}
}
/// <summary>Validates format of given value.</summary>
/// <param name="value">String value.</param>
/// <param name="tokenType">Type of token holding the value.</param>
/// <returns>True if value is correct for given format, False - if not.</returns>
public bool IsValid(string value, JTokenType tokenType)
{
return((value.Length % 4 == 0) &&
Regex.IsMatch(value, Base64Expression, RegexOptions.None));
}
internal JValue(object value, JTokenType type)
{
this._value = value;
this._valueType = type;
}
internal static int Compare(JTokenType valueType, object objA, object objB)
{
if (objA == objB)
{
return(0);
}
if (objB == null)
{
return(1);
}
if (objA == null)
{
return(-1);
}
switch (valueType)
{
case JTokenType.Integer:
#if HAVE_BIG_INTEGER
if (objA is BigInteger)
{
return(CompareBigInteger((BigInteger)objA, objB));
}
if (objB is BigInteger)
{
return(-CompareBigInteger((BigInteger)objB, objA));
}
#endif
if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
{
return(Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture)));
}
else if (objA is float || objB is float || objA is double || objB is double)
{
return(CompareFloat(objA, objB));
}
else
{
return(Convert.ToInt64(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(objB, CultureInfo.InvariantCulture)));
}
case JTokenType.Float:
#if HAVE_BIG_INTEGER
if (objA is BigInteger)
{
return(CompareBigInteger((BigInteger)objA, objB));
}
if (objB is BigInteger)
{
return(-CompareBigInteger((BigInteger)objB, objA));
}
#endif
if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
{
return(Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture)));
}
return(CompareFloat(objA, objB));
case JTokenType.Comment:
case JTokenType.String:
case JTokenType.Raw:
string s1 = Convert.ToString(objA, CultureInfo.InvariantCulture);
string s2 = Convert.ToString(objB, CultureInfo.InvariantCulture);
return(string.CompareOrdinal(s1, s2));
case JTokenType.Boolean:
bool b1 = Convert.ToBoolean(objA, CultureInfo.InvariantCulture);
bool b2 = Convert.ToBoolean(objB, CultureInfo.InvariantCulture);
return(b1.CompareTo(b2));
case JTokenType.Date:
#if HAVE_DATE_TIME_OFFSET
if (objA is DateTime)
{
#endif
DateTime date1 = (DateTime)objA;
DateTime date2;
#if HAVE_DATE_TIME_OFFSET
if (objB is DateTimeOffset)
{
date2 = ((DateTimeOffset)objB).DateTime;
}
else
#endif
{
date2 = Convert.ToDateTime(objB, CultureInfo.InvariantCulture);
}
return(date1.CompareTo(date2));
#if HAVE_DATE_TIME_OFFSET
}
else
{
DateTimeOffset date1 = (DateTimeOffset)objA;
DateTimeOffset date2;
if (objB is DateTimeOffset)
{
date2 = (DateTimeOffset)objB;
}
else
{
date2 = new DateTimeOffset(Convert.ToDateTime(objB, CultureInfo.InvariantCulture));
}
return(date1.CompareTo(date2));
}
#endif
case JTokenType.Bytes:
byte[] bytes2 = objB as byte[];
if (bytes2 == null)
{
throw new ArgumentException("Object must be of type byte[].");
}
byte[] bytes1 = objA as byte[];
Debug.Assert(bytes1 != null);
return(MiscellaneousUtils.ByteArrayCompare(bytes1, bytes2));
case JTokenType.Guid:
if (!(objB is Guid))
{
throw new ArgumentException("Object must be of type Guid.");
}
Guid guid1 = (Guid)objA;
Guid guid2 = (Guid)objB;
return(guid1.CompareTo(guid2));
case JTokenType.Uri:
Uri uri2 = objB as Uri;
if (uri2 == null)
{
throw new ArgumentException("Object must be of type Uri.");
}
Uri uri1 = (Uri)objA;
return(Comparer <string> .Default.Compare(uri1.ToString(), uri2.ToString()));
case JTokenType.TimeSpan:
if (!(objB is TimeSpan))
{
throw new ArgumentException("Object must be of type TimeSpan.");
}
TimeSpan ts1 = (TimeSpan)objA;
TimeSpan ts2 = (TimeSpan)objB;
return(ts1.CompareTo(ts2));
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException(nameof(valueType), valueType, "Unexpected value type: {0}".FormatWith(CultureInfo.InvariantCulture, valueType));
}
}
private static bool IsValidType(JTokenType type)
{
return(ValidTypes.Contains(type));
}
private static double SerializeAsDouble(JToken value, JTokenType columnType)
{
return value.Value<double>();
}
public static dynamic CheckRequiredJsonField(ref JObject json, string field_name, JTokenType field_type, ref Socket remoteSocket)
{
if (json == null)
{
Logger.WriteLog("Insert json is null, function CheckRequiredJsonField", LogLevel.Error);
return(null);
}
if (json.ContainsKey(field_name))
{
JToken token = json.GetValue(field_name);
if (token.Type == field_type)
{
return(token);
}
else
{
Logger.WriteLog("Required field is not in correct format, field_name=" + field_name + " field_type=" + field_type, LogLevel.Error);
JsonAnswer(false, "Required field is not in correct format, field_name=" + field_name + " field_type=" + field_type, ref remoteSocket);
return(null);
}
}
else
{
Logger.WriteLog("Json does not contain required field, field_name=" + field_name, LogLevel.Error);
JsonAnswer(false, "Json does not contain required field, field_name=" + field_name, ref remoteSocket);
return(null);
}
}
private static string SerializeAsText(JToken value, JTokenType columnType)
{
return value.ToString();
}
/// <summary>
/// Generate a JSON Schema (Draft 4) for a particular JToken object.
/// </summary>
/// <remarks>
/// https://gist.github.com/fractos/2967ea77b89b4634f51c
/// Porting some Python code that generates a JSON Schema (Draft 4 compatible - http://json-schema.org/).
/// Python original by @perenecabuto at - https://github.com/perenecabuto/json_schema_generator
/// </remarks>
/// <param name="self"></param>
/// <param name="schemaVersion"></param>
/// <param name="idPrefix"></param>
/// <param name="parentId"></param>
/// <param name="objectId"></param>
/// <param name="firstLevel"></param>
/// <returns></returns>
public static JObject GenerateSchema(this JToken self, string schemaVersion, string idPrefix, string parentId, string objectId = "", bool firstLevel = true, GenerateSchemaOptions options = null)
{
if (options == null)
{
options = GenerateSchemaOptions.Default;
}
JObject schema = new JObject();
if (firstLevel)
{
schema.Add("$schema", schemaVersion);
}
string id = String.Concat(firstLevel ? idPrefix : parentId, "/", objectId);
if (options.IncludeId)
{
schema.Add("id", id);
}
schema.Add("type", Enum.GetName(typeof(JTokenType), self.Type).ToLower());
if (options.IncludeTitle)
{
schema.Add("title", firstLevel ? "Root schema" : String.Concat(objectId, " schema"));
}
if (options.IncludeDescription)
{
schema.Add("description", "Add description here");
}
//schema.Add("name", firstLevel ? "/" : objectId);
if (self.Type == JTokenType.Object)
{
JObject properties = new JObject();
foreach (JProperty property in ((JObject)self).Properties())
{
properties.Add(property.Name, property.Value.GenerateSchema(schemaVersion, idPrefix, id, property.Name, firstLevel: false, options: options));
}
schema.Add("properties", properties);
}
else if (self.Type == JTokenType.Array && self.HasValues)
{
JTokenType firstType = self.Values().First().Type;
bool sameType = self.Values().All(v => v.Type == firstType);
if (sameType)
{
schema.Add("items", self.Values().First().GenerateSchema(schemaVersion, idPrefix, id, "0", firstLevel: false, options: options));
}
else
{
schema.Add("items", new JArray());
List <JToken> children = self.Values().ToList();
for (int x = 0; x < children.Count; x++)
{
JToken child = children[x];
((JArray)schema["items"]).Add(child.GenerateSchema(schemaVersion, idPrefix, id, x.ToString(), firstLevel: false, options: options));
}
}
}
return(schema);
}
public static JToken ParseBoolean(JTokenType type, object value)
{
bool boolValue = (value as bool?).GetValueOrDefault();
return boolValue;
}
private static int Compare(JTokenType valueType, object objA, object objB)
{
if (objA == null && objB == null)
{
return(0);
}
if (objA != null && objB == null)
{
return(1);
}
if (objA != null || objB == null)
{
switch (valueType)
{
case JTokenType.Integer:
if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
{
return(Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture)));
}
if (objA is float || objB is float || objA is double || objB is double)
{
return(CompareFloat(objA, objB));
}
return(Convert.ToInt64(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(objB, CultureInfo.InvariantCulture)));
case JTokenType.Float:
return(CompareFloat(objA, objB));
case JTokenType.Comment:
case JTokenType.String:
case JTokenType.Raw:
{
string text = Convert.ToString(objA, CultureInfo.InvariantCulture);
string strB = Convert.ToString(objB, CultureInfo.InvariantCulture);
return(text.CompareTo(strB));
}
case JTokenType.Boolean:
{
bool flag = Convert.ToBoolean(objA, CultureInfo.InvariantCulture);
bool value3 = Convert.ToBoolean(objB, CultureInfo.InvariantCulture);
return(flag.CompareTo(value3));
}
case JTokenType.Date:
{
if (objA is DateTime)
{
DateTime dateTime = Convert.ToDateTime(objA, CultureInfo.InvariantCulture);
DateTime value2 = Convert.ToDateTime(objB, CultureInfo.InvariantCulture);
return(dateTime.CompareTo(value2));
}
if (!(objB is DateTimeOffset))
{
throw new ArgumentException("Object must be of type DateTimeOffset.");
}
DateTimeOffset dateTimeOffset = (DateTimeOffset)objA;
DateTimeOffset other = (DateTimeOffset)objB;
return(dateTimeOffset.CompareTo(other));
}
case JTokenType.Bytes:
{
if (!(objB is byte[]))
{
throw new ArgumentException("Object must be of type byte[].");
}
byte[] array = objA as byte[];
byte[] array2 = objB as byte[];
if (array == null)
{
return(-1);
}
if (array2 == null)
{
return(1);
}
return(MiscellaneousUtils.ByteArrayCompare(array, array2));
}
case JTokenType.Guid:
{
if (!(objB is Guid))
{
throw new ArgumentException("Object must be of type Guid.");
}
Guid guid = (Guid)objA;
Guid value4 = (Guid)objB;
return(guid.CompareTo(value4));
}
case JTokenType.Uri:
{
if (!(objB is Uri))
{
throw new ArgumentException("Object must be of type Uri.");
}
Uri uri = (Uri)objA;
Uri uri2 = (Uri)objB;
return(Comparer <string> .Default.Compare(uri.ToString(), uri2.ToString()));
}
case JTokenType.TimeSpan:
{
if (!(objB is TimeSpan))
{
throw new ArgumentException("Object must be of type TimeSpan.");
}
TimeSpan timeSpan = (TimeSpan)objA;
TimeSpan value = (TimeSpan)objB;
return(timeSpan.CompareTo(value));
}
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("valueType", valueType, "Unexpected value type: {0}".FormatWith(CultureInfo.InvariantCulture, valueType));
}
}
return(-1);
}
private void WriteEnd(JTokenType type)
{
switch (type)
{
case JTokenType.Object:
WriteEndObject();
break;
case JTokenType.Array:
WriteEndArray();
break;
case JTokenType.Constructor:
WriteEndConstructor();
break;
default:
throw new JsonWriterException("Unexpected type when writing end: " + type);
}
}
public JObjectValidationParameter(string key, JTokenType type)
{
this.key = key;
this.type = type;
}
private static bool IsNull(JTokenType type)
{
return type == JTokenType.Null || type == JTokenType.Undefined;
}
public static JToken ParseBoolean(JTokenType type, object value)
{
bool boolValue = (value as bool?).GetValueOrDefault();
return(boolValue);
}
internal JValue(object value, JTokenType type)
{
_value = value;
_valueType = type;
}
private void WriteValueElement(JTokenType type)
{
if (_propertyName != null)
{
WriteValueElement(_propertyName, type);
_propertyName = null;
}
else
{
WriteValueElement("Item", type);
}
}
private static JTokenType GetValueType(JTokenType? current, object value)
{
if (value == null)
return JTokenType.Null;
else if (value is string)
return GetStringValueType(current);
else if (value is long || value is int || value is short || value is sbyte
|| value is ulong || value is uint || value is ushort || value is byte)
return JTokenType.Integer;
else if (value is double || value is float || value is decimal)
return JTokenType.Float;
else if (value is DateTime)
return JTokenType.Date;
else if (value is DateTimeOffset)
return JTokenType.Date;
else if (value is bool)
return JTokenType.Boolean;
throw new ArgumentException("Could not determin JSON object type for type {0}.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
}
private static int Compare(JTokenType valueType, object objA, object objB)
{
if (objA == null && objB == null)
{
return(0);
}
if (objA != null && objB == null)
{
return(1);
}
if (objA == null && objB != null)
{
return(-1);
}
switch (valueType)
{
case JTokenType.Integer:
if (objA is ulong || objB is ulong || objA is decimal || objB is decimal)
{
return(Convert.ToDecimal(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToDecimal(objB, CultureInfo.InvariantCulture)));
}
else if (objA is float || objB is float || objA is double || objB is double)
{
return(CompareFloat(objA, objB));
}
else
{
return(Convert.ToInt64(objA, CultureInfo.InvariantCulture).CompareTo(Convert.ToInt64(objB, CultureInfo.InvariantCulture)));
}
case JTokenType.Float:
return(CompareFloat(objA, objB));
case JTokenType.Comment:
case JTokenType.String:
case JTokenType.Raw:
string s1 = Convert.ToString(objA, CultureInfo.InvariantCulture);
string s2 = Convert.ToString(objB, CultureInfo.InvariantCulture);
return(s1.CompareTo(s2));
case JTokenType.Boolean:
bool b1 = Convert.ToBoolean(objA, CultureInfo.InvariantCulture);
bool b2 = Convert.ToBoolean(objB, CultureInfo.InvariantCulture);
return(b1.CompareTo(b2));
case JTokenType.Date:
if (objA is DateTime)
{
DateTime date1 = Convert.ToDateTime(objA, CultureInfo.InvariantCulture);
DateTime date2 = Convert.ToDateTime(objB, CultureInfo.InvariantCulture);
return(date1.CompareTo(date2));
}
else
{
if (!(objB is DateTimeOffset))
{
throw new ArgumentException("Object must be of type DateTimeOffset.");
}
DateTimeOffset date1 = (DateTimeOffset)objA;
DateTimeOffset date2 = (DateTimeOffset)objB;
return(date1.CompareTo(date2));
}
case JTokenType.Bytes:
if (!(objB is byte[]))
{
throw new ArgumentException("Object must be of type byte[].");
}
byte[] bytes1 = objA as byte[];
byte[] bytes2 = objB as byte[];
if (bytes1 == null)
{
return(-1);
}
if (bytes2 == null)
{
return(1);
}
return(MiscellaneousUtils.ByteArrayCompare(bytes1, bytes2));
case JTokenType.Guid:
if (!(objB is Guid))
{
throw new ArgumentException("Object must be of type Guid.");
}
Guid guid1 = (Guid)objA;
Guid guid2 = (Guid)objB;
return(guid1.CompareTo(guid2));
case JTokenType.Uri:
if (!(objB is Uri))
{
throw new ArgumentException("Object must be of type Uri.");
}
Uri uri1 = (Uri)objA;
Uri uri2 = (Uri)objB;
return(Comparer <string> .Default.Compare(uri1.ToString(), uri2.ToString()));
case JTokenType.TimeSpan:
if (!(objB is TimeSpan))
{
throw new ArgumentException("Object must be of type TimeSpan.");
}
TimeSpan ts1 = (TimeSpan)objA;
TimeSpan ts2 = (TimeSpan)objB;
return(ts1.CompareTo(ts2));
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("valueType", valueType, "Unexpected value type: {0}".FormatWith(CultureInfo.InvariantCulture, valueType));
}
}
private void Push(JTokenType value)
{
_stack.Add(value);
_top++;
_currentTypeContext = value;
}
/// <summary>Validates if a string is valid DateTime.</summary>
/// <param name="value">String value.</param>
/// <param name="tokenType">Type of token holding the value.</param>
/// <returns></returns>
public bool IsValid(string value, JTokenType tokenType)
{
return(tokenType == JTokenType.Date ||
DateTimeOffset.TryParseExact(value, _acceptableFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTimeOffset dateTimeResult));
}
protected virtual void SetToken(JsonToken newToken, object value)
{
_token = newToken;
switch (newToken)
{
case JsonToken.StartObject:
_currentState = State.ObjectStart;
Push(JTokenType.Object);
break;
case JsonToken.StartArray:
_currentState = State.ArrayStart;
Push(JTokenType.Array);
break;
case JsonToken.StartConstructor:
_currentState = State.ConstructorStart;
Push(JTokenType.Constructor);
break;
case JsonToken.EndObject:
ValidateEnd(JsonToken.EndObject);
_currentState = State.PostValue;
break;
case JsonToken.EndArray:
ValidateEnd(JsonToken.EndArray);
_currentState = State.PostValue;
break;
case JsonToken.EndConstructor:
ValidateEnd(JsonToken.EndConstructor);
_currentState = State.PostValue;
break;
case JsonToken.PropertyName:
_currentState = State.Property;
Push(JTokenType.Property);
break;
case JsonToken.Raw:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.Date:
case JsonToken.Bytes:
_currentState = State.PostValue;
break;
}
JTokenType jTokenType = Peek();
if (jTokenType == JTokenType.Property && _currentState == State.PostValue)
{
Pop();
}
if (value != null)
{
_value = value;
_valueType = value.GetType();
}
else
{
_value = null;
_valueType = null;
}
}
public static JToken ParseUniqueIdentier(JTokenType type, object value)
{
return((Guid)value);
}
private JToken GetValue(JObject json, string propertyName, JTokenType expectedType, bool removeProperty = false)
{
JToken value;
if( json.TryGetValue(propertyName, out value) == false || value.Type != expectedType )
{
var exception = new Exception("Json is not valid graph node json.");
exception.Data["json"] = json.ToString();
throw exception;
}
if (removeProperty == true)
json.Remove(propertyName);
return value;
}
private void Push(JTokenType value)
{
_stack.Add(value);
_top++;
_currentTypeContext = value;
}
private void WriteValueElement(string elementName, JTokenType type)
{
_writer.WriteStartElement(elementName);
_writer.WriteAttributeString("type", type.ToString());
}
private static bool IsNull(JTokenType type)
{
return(type == JTokenType.Null || type == JTokenType.Undefined);
}
