public void NullSerialize()
{
var Serializer = new JsonSerializer();
Assert.Equal("", Serializer.Serialize(typeof(object), null));
Assert.Equal("", Serializer.Serialize(null, new { A = "" }));
Assert.Equal("", Serializer.Serialize(null, null));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var analysisValue = (AnalysisSettings)value;
writer.WriteStartObject();
{
if (analysisValue.Analyzers.Count > 0)
{
writer.WritePropertyName("analyzer");
serializer.Serialize(writer, analysisValue.Analyzers);
}
if (analysisValue.TokenFilters.Count > 0)
{
writer.WritePropertyName("filter");
serializer.Serialize(writer, analysisValue.TokenFilters);
}
if (analysisValue.Tokenizers.Count > 0)
{
writer.WritePropertyName("tokenizer");
serializer.Serialize(writer, analysisValue.Tokenizers);
}
if (analysisValue.CharFilters.Count > 0)
{
writer.WritePropertyName("char_filter");
serializer.Serialize(writer, analysisValue.CharFilters);
}
}
writer.WriteEndObject();
}
public bool TryWriteFeature(JsonWriter writer, object value, JsonSerializer serializer)
{
if (!_shapeConverter.CanConvert(ObjectType.Feature))
return false;
ObjectType geomType = _shapeConverter.GetObjectType(value);
if (geomType != ObjectType.Feature)
return false;
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue(Enum.GetName(typeof(ObjectType), ObjectType.Feature));
object id;
Dictionary<string, object> props;
var geometry = _shapeConverter.FromFeature(value, out id, out props);
if (id != null)
{
writer.WritePropertyName("id");
serializer.Serialize(writer, id);
}
if (props != null && props.Count > 0)
{
writer.WritePropertyName("properties");
serializer.Serialize(writer, props);
}
writer.WritePropertyName("geometry");
serializer.Serialize(writer, geometry);
writer.WriteEndObject();
return true;
}
public void Serialize()
{
var Serializer = new JsonSerializer();
dynamic Object = new { A = 5, B = "ASDF" };
Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object));
Object = new TestObject { A = 5, B = "ASDF" };
Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object));
}
public void TestGetPlaylist()
{
var playlists = soundCloudClient.User(settings.TestUserId).GetPlaylists();
if (playlists.Length == 0)
return;
var playlist = soundCloudClient.Playlist(playlists[0].Id).GetPlaylist();
var jsonSerializer = new JsonSerializer();
Assert.AreEqual(jsonSerializer.Serialize(playlists[0]), jsonSerializer.Serialize(playlist));
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
writer.WriteEndObject();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Type t = value.GetType();
PropertyInfo keyProperty = t.GetProperty("Key");
PropertyInfo valueProperty = t.GetProperty("Value");
writer.WriteStartObject();
writer.WritePropertyName("Key");
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
writer.WritePropertyName("Value");
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var mapping = (WarmerMapping) value;
writer.WriteStartObject();
writer.WritePropertyName("types");
serializer.Serialize(writer, mapping.Types);
writer.WritePropertyName("source");
serializer.Serialize(writer, mapping.Source);
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var f = value as ITermsBaseFilter;
if (f == null || (f.IsConditionless && !f.IsVerbatim)) return;
var contract = serializer.ContractResolver as SettingsContractResolver;
if (contract == null)
return;
var field = contract.Infer.PropertyPath(f.Field);
if (field.IsNullOrEmpty())
return;
writer.WriteStartObject();
{
var lf = f as ITermsLookupFilter;
if (lf != null)
{
writer.WritePropertyName(field);
writer.WriteStartObject();
{
WriteProperty(writer, f, "id", lf.Id);
SerializeProperty(writer, serializer, f, "type", lf.Type);
SerializeProperty(writer, serializer, f, "index", lf.Index);
SerializeProperty(writer, serializer, f, "path", lf.Path);
WriteProperty(writer, f, "routing", lf.Routing);
WriteProperty(writer, f, "cache", lf.CacheLookup);
}
writer.WriteEndObject();
}
var tf = f as ITermsFilter;
if (tf != null)
{
writer.WritePropertyName(field);
serializer.Serialize(writer, tf.Terms);
}
if (f.Execution.HasValue)
{
writer.WritePropertyName("execution");
serializer.Serialize(writer, f.Execution.Value);
}
WriteProperty(writer, f, "_cache", f.Cache);
WriteProperty(writer, f, "_cache_key", f.CacheKey);
WriteProperty(writer, f, "_name", f.FilterName);
}
writer.WriteEndObject();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Type t = value.GetType();
PropertyInfo keyProperty = t.GetProperty(KeyName);
PropertyInfo valueProperty = t.GetProperty(ValueName);
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value));
writer.WriteEndObject();
}
public void EntitiesTest()
{
Purchase purchase = new Purchase() { Id = 1 };
purchase.PurchaseLine.Add(new PurchaseLine() { Id = 1, Purchase = purchase });
purchase.PurchaseLine.Add(new PurchaseLine() { Id = 2, Purchase = purchase });
StringWriter sw = new StringWriter();
JsonSerializer serializer = new JsonSerializer();
serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
using (JsonWriter jw = new JsonTextWriter(sw))
{
jw.Formatting = Formatting.Indented;
serializer.Serialize(jw, purchase);
}
string json = sw.ToString();
Assert.AreEqual(@"{
""Id"": 1,
""PurchaseLine"": [
{
""Id"": 1,
""PurchaseReference"": {
""EntityKey"": null,
""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"",
""SourceRoleName"": ""PurchaseLine"",
""TargetRoleName"": ""Purchase"",
""RelationshipSet"": null,
""IsLoaded"": false
},
""EntityState"": 1,
""EntityKey"": null
},
{
""Id"": 2,
""PurchaseReference"": {
""EntityKey"": null,
""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"",
""SourceRoleName"": ""PurchaseLine"",
""TargetRoleName"": ""Purchase"",
""RelationshipSet"": null,
""IsLoaded"": false
},
""EntityState"": 1,
""EntityKey"": null
}
],
""EntityState"": 1,
""EntityKey"": null
}", json);
Purchase newPurchase = JsonConvert.DeserializeObject<Purchase>(json);
Assert.AreEqual(1, newPurchase.Id);
Assert.AreEqual(2, newPurchase.PurchaseLine.Count);
Assert.AreEqual(1, newPurchase.PurchaseLine.ElementAt(0).Id);
Assert.AreEqual(2, newPurchase.PurchaseLine.ElementAt(1).Id);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DataTable table = (DataTable)value;
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartArray();
foreach (DataRow row in table.Rows)
{
writer.WriteStartObject();
foreach (DataColumn column in row.Table.Columns)
{
object columnValue = row[column];
if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
{
continue;
}
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
serializer.Serialize(writer, columnValue);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
private static void SerializeProperty(JsonWriter writer, JsonSerializer serializer , IFilter filter, string field, object value)
{
if ((field.IsNullOrEmpty() || value == null))
return;
writer.WritePropertyName(field);
serializer.Serialize(writer, value);
}
public void WhenSerializeWithMoreDatatypes_GetSerialiedJsonString()
{
// Arrange
var jsonSerializer = new JsonSerializer();
var jsonMoreDataTypes = new JsonMoreDataTypes
{
BoolProperty = true,
ByteProperty = 1,
SByteProperty = 2,
CharProperty = 'K',
DoubleProperty = 12.52,
FloatProperty = 12.52F,
IntProperty = 15789,
UIntProperty = 1234,
LongProperty = 152,
ULongProperty = 12345,
ShortProperty = 123,
UShortProperty = 555,
StringProperty = "This is a string"
};
// Act
var result = jsonSerializer.Serialize(jsonMoreDataTypes);
// Assert
Assert.AreEqual("{\"boolProperty\": true,\"byteProperty\": 1,\"sByteProperty\": 2,\"charProperty\": \"K\",\"doubleProperty\": 12.52,\"floatProperty\": 12.5200005,\"intProperty\": 15789,\"uIntProperty\": 1234,\"longProperty\": 152,\"uLongProperty\": 12345,\"shortProperty\": 123,\"uShortProperty\": 555,\"stringProperty\": \"This is a string\"}", result);
}
public void JsonSerializer_Serialize_GivenNullInput_ShouldReturnNull()
{
var jsonSerializer = new JsonSerializer();
var result = jsonSerializer.Serialize<object>(null);
Assert.IsNull(result);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="T:Raven.Imports.Newtonsoft.Json.JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
if (value.GetType() == typeof (object))
{
writer.WriteStartObject();
writer.WriteEndObject();
return;
}
var dynamicValue = ((IDynamicMetaObjectProvider) value).GetMetaObject(Expression.Constant(value));
writer.WriteStartObject();
foreach (var dynamicMemberName in dynamicValue.GetDynamicMemberNames())
{
writer.WritePropertyName(dynamicMemberName);
var memberValue = DynamicUtil.GetValueDynamically(value, dynamicMemberName);
if(memberValue == null || memberValue is ValueType || memberValue is string)
writer.WriteValue(memberValue);
else
serializer.Serialize(writer, memberValue);
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var contract = serializer.ContractResolver as SettingsContractResolver;
IDictionary dictionary = (IDictionary) value;
writer.WriteStartObject();
foreach (DictionaryEntry entry in dictionary)
{
if (entry.Value == null)
continue;
string key;
var pp = entry.Key as PropertyPathMarker;
var pn = entry.Key as PropertyNameMarker;
var im = entry.Key as IndexNameMarker;
if (contract == null)
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
else if (pp != null)
key = contract.Infer.PropertyPath(pp);
else if (pn != null)
key = contract.Infer.PropertyName(pn);
else if (im != null)
key = contract.Infer.IndexName(im);
else
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
writer.WritePropertyName(key);
serializer.Serialize(writer, entry.Value);
}
writer.WriteEndObject();
}
protected void BuyButton_Click(object sender, EventArgs e)
{
if (Contact != null)
{
try
{
ICredentialProvider credentialProvider = new UserCredentialProvider(MembershipContext.AuthenticatedUser);
NetworkCredential userCredential = credentialProvider.GetCredential();
if (userCredential != null)
{
DataComClient client = DataComHelper.CreateClient();
IContactProvider provider = new UserContactProvider(client, userCredential);
Contact contact = provider.GetContact(Contact.ContactId, true);
JsonSerializer serializer = new JsonSerializer();
ContactHiddenField.Value = serializer.Serialize(contact);
}
else
{
ErrorSummary.Report(GetString("datacom.nousercredential"));
BuyButton.Enabled = false;
}
}
catch (Exception exception)
{
HandleException(exception);
}
}
}
public static string ToJson(object obj, bool format=false)
{
if(format)
{
JsonSerializer serializer = new JsonSerializer();
StringBuilder sb = new StringBuilder();
using (var writer = new StringWriter(sb))
{
using(var jsonWriter = new JsonTextWriter(writer) { Formatting=Formatting.Indented })
{
serializer.Serialize(jsonWriter, obj);
return sb.ToString();
}
}
}
else
{
JsonSerializer serializer = new JsonSerializer();
StringBuilder sb = new StringBuilder();
using(var writer = new StringWriter(sb))
{
serializer.Serialize(writer, obj);
return sb.ToString();
}
}
}
public void CanSerializeWithEncryptRootObjectEnabled()
{
var encryptionMechanism = new Base64EncryptionMechanism();
var configuration = new JsonSerializerConfiguration
{
EncryptionMechanism = encryptionMechanism,
EncryptRootObject = true
};
var serializer = new JsonSerializer<Bar>(configuration);
var instance = new Bar
{
Baz = new Baz
{
Qux = "abc",
Garply = true
},
Corge = 123.45
};
var json = serializer.Serialize(instance);
var expected =
@""""
+ encryptionMechanism.Encrypt(@"{""Baz"":{""Qux"":""abc"",""Garply"":true},""Corge"":123.45}")
+ @"""";
Assert.That(json, Is.EqualTo(expected));
}
public void TestBasicSerialization()
{
var serializer = new JsonSerializer();
var expected = CA<PlanDto>();
var json = serializer.Serialize(expected);
Compare(serializer.Deserialize<PlanDto>(json), expected);
}
public void AClassDecoratedWithTheEncryptAttributeIsEncrypted()
{
var encryptionMechanism = new Base64EncryptionMechanism();
var configuration = new JsonSerializerConfiguration
{
EncryptionMechanism = encryptionMechanism,
};
var serializer = new JsonSerializer<Grault>(configuration);
var instance = new Grault
{
Qux = "abc",
Garply = true
};
var json = serializer.Serialize(instance);
var expected =
@""""
+ encryptionMechanism.Encrypt(@"{""Qux"":""abc"",""Garply"":true}")
+ @"""";
Assert.That(json, Is.EqualTo(expected));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var f = value as IFilterAggregator;
if (f == null || f.Filter == null) return;
serializer.Serialize(writer, f.Filter);
}
public static void WriteLargeJson()
{
var json = System.IO.File.ReadAllText("large.json");
IList<PerformanceTests.RootObject> o = JsonConvert.DeserializeObject<IList<PerformanceTests.RootObject>>(json);
Console.WriteLine("Press any key to start serialize");
Console.ReadKey();
Console.WriteLine("Serializing...");
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 100; i++)
{
using (StreamWriter file = System.IO.File.CreateText("largewrite.json"))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Formatting = Formatting.Indented;
serializer.Serialize(file, o);
}
}
sw.Stop();
Console.WriteLine("Finished. Total seconds: " + sw.Elapsed.TotalSeconds);
}
public void CyclicalObject()
{
var serializer = new JsonSerializer();
var a = new CyclicalObject_Class();
a.A = a;
string result = serializer.Serialize(a);
}
public void JsonSerializer_ShouldReturnCorrectResultWhenInputHasNoProperies()
{
var serializer = new JsonSerializer();
Player input = new Player { };
string expResult = "{\"Name\":null,\"Score\":0,\"Id\":null}";
Assert.AreEqual(expResult, serializer.Serialize<Player>(input));
}
public void CanSerialize(bool value, string expected)
{
var serializer = new JsonSerializer<bool>();
var json = serializer.Serialize(value);
Assert.That(json, Is.EqualTo(expected));
}
public void CanSerializeNullableDateTimeNullValue()
{
var serializer = new JsonSerializer<DateTime?>();
var json = serializer.Serialize(null);
Assert.That(json, Is.EqualTo("null"));
}
public void CanSerialize()
{
var serializer = new JsonSerializer<string>();
var json = serializer.Serialize("abc");
Assert.That(json, Is.EqualTo(@"""abc"""));
}
public void JsonSerializer_ShouldReturnCorrectResultWhenCorrectInput()
{
var serializer = new JsonSerializer();
Player input = new Player { Name = "Test", Score = 65, Id = "1" };
string expResult = "{\"Name\":\"Test\",\"Score\":65,\"Id\":\"1\"}";
Assert.AreEqual(expResult, serializer.Serialize<Player>(input));
}
void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
{
writer.WriteStartObject();
if (Optional.IsDefined(Kind))
{
writer.WritePropertyName("kind");
writer.WriteStringValue(Kind.Value.ToString());
}
if (Optional.IsDefined(Identity))
{
writer.WritePropertyName("identity");
JsonSerializer.Serialize(writer, Identity);
}
writer.WritePropertyName("tags");
writer.WriteStartObject();
foreach (var item in Tags)
{
writer.WritePropertyName(item.Key);
writer.WriteStringValue(item.Value);
}
writer.WriteEndObject();
writer.WritePropertyName("location");
writer.WriteStringValue(Location);
writer.WritePropertyName("properties");
writer.WriteStartObject();
if (Optional.IsDefined(ConsistencyPolicy))
{
writer.WritePropertyName("consistencyPolicy");
writer.WriteObjectValue(ConsistencyPolicy);
}
writer.WritePropertyName("locations");
writer.WriteStartArray();
foreach (var item in Locations)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
writer.WritePropertyName("databaseAccountOfferType");
writer.WriteStringValue(DatabaseAccountOfferType);
if (Optional.IsCollectionDefined(IpRules))
{
writer.WritePropertyName("ipRules");
writer.WriteStartArray();
foreach (var item in IpRules)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (Optional.IsDefined(IsVirtualNetworkFilterEnabled))
{
writer.WritePropertyName("isVirtualNetworkFilterEnabled");
writer.WriteBooleanValue(IsVirtualNetworkFilterEnabled.Value);
}
if (Optional.IsDefined(EnableAutomaticFailover))
{
writer.WritePropertyName("enableAutomaticFailover");
writer.WriteBooleanValue(EnableAutomaticFailover.Value);
}
if (Optional.IsCollectionDefined(Capabilities))
{
writer.WritePropertyName("capabilities");
writer.WriteStartArray();
foreach (var item in Capabilities)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (Optional.IsCollectionDefined(VirtualNetworkRules))
{
writer.WritePropertyName("virtualNetworkRules");
writer.WriteStartArray();
foreach (var item in VirtualNetworkRules)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (Optional.IsDefined(EnableMultipleWriteLocations))
{
writer.WritePropertyName("enableMultipleWriteLocations");
writer.WriteBooleanValue(EnableMultipleWriteLocations.Value);
}
if (Optional.IsDefined(EnableCassandraConnector))
{
writer.WritePropertyName("enableCassandraConnector");
writer.WriteBooleanValue(EnableCassandraConnector.Value);
}
if (Optional.IsDefined(ConnectorOffer))
{
writer.WritePropertyName("connectorOffer");
writer.WriteStringValue(ConnectorOffer.Value.ToString());
}
if (Optional.IsDefined(DisableKeyBasedMetadataWriteAccess))
{
writer.WritePropertyName("disableKeyBasedMetadataWriteAccess");
writer.WriteBooleanValue(DisableKeyBasedMetadataWriteAccess.Value);
}
if (Optional.IsDefined(KeyVaultKeyUri))
{
writer.WritePropertyName("keyVaultKeyUri");
writer.WriteStringValue(KeyVaultKeyUri.AbsoluteUri);
}
if (Optional.IsDefined(DefaultIdentity))
{
writer.WritePropertyName("defaultIdentity");
writer.WriteStringValue(DefaultIdentity);
}
if (Optional.IsDefined(PublicNetworkAccess))
{
writer.WritePropertyName("publicNetworkAccess");
writer.WriteStringValue(PublicNetworkAccess.Value.ToString());
}
if (Optional.IsDefined(EnableFreeTier))
{
writer.WritePropertyName("enableFreeTier");
writer.WriteBooleanValue(EnableFreeTier.Value);
}
if (Optional.IsDefined(ApiProperties))
{
writer.WritePropertyName("apiProperties");
writer.WriteObjectValue(ApiProperties);
}
if (Optional.IsDefined(EnableAnalyticalStorage))
{
writer.WritePropertyName("enableAnalyticalStorage");
writer.WriteBooleanValue(EnableAnalyticalStorage.Value);
}
if (Optional.IsDefined(AnalyticalStorageConfiguration))
{
writer.WritePropertyName("analyticalStorageConfiguration");
writer.WriteObjectValue(AnalyticalStorageConfiguration);
}
if (Optional.IsDefined(CreateMode))
{
writer.WritePropertyName("createMode");
writer.WriteStringValue(CreateMode.Value.ToString());
}
if (Optional.IsDefined(BackupPolicy))
{
writer.WritePropertyName("backupPolicy");
writer.WriteObjectValue(BackupPolicy);
}
if (Optional.IsCollectionDefined(Cors))
{
writer.WritePropertyName("cors");
writer.WriteStartArray();
foreach (var item in Cors)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (Optional.IsDefined(NetworkAclBypass))
{
writer.WritePropertyName("networkAclBypass");
writer.WriteStringValue(NetworkAclBypass.Value.ToSerialString());
}
if (Optional.IsCollectionDefined(NetworkAclBypassResourceIds))
{
writer.WritePropertyName("networkAclBypassResourceIds");
writer.WriteStartArray();
foreach (var item in NetworkAclBypassResourceIds)
{
writer.WriteStringValue(item);
}
writer.WriteEndArray();
}
if (Optional.IsDefined(DisableLocalAuth))
{
writer.WritePropertyName("disableLocalAuth");
writer.WriteBooleanValue(DisableLocalAuth.Value);
}
if (Optional.IsDefined(RestoreParameters))
{
writer.WritePropertyName("restoreParameters");
writer.WriteObjectValue(RestoreParameters);
}
if (Optional.IsDefined(Capacity))
{
writer.WritePropertyName("capacity");
writer.WriteObjectValue(Capacity);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
public string ToJsonString()
{
return(JsonSerializer.Serialize(this));
}
public IActionResult Post(Pass pass)
{
//var result = JsonSerializer.Deserialize<Pass>(pass);
return(Ok(JsonSerializer.Serialize(DbUtils.Post(pass))));
}
public static void Set <T>(this ISession session, string key, T value)
{
session.SetString(key, JsonSerializer.Serialize <T>(value));
}
public JsonContent(object obj) :
base(JsonSerializer.Serialize(obj), Encoding.UTF8, "application/json")
{
}
public override string ToString() => JsonSerializer.Serialize(this);
public async Task <ProjectBuildResult> BuildAsync(ProjectBuildArgs args)
{
var templateInfo = GetTemplateInfo(args);
NormalizeArgs(args, templateInfo);
var templateFile = await TemplateStore.GetAsync(
args.TemplateName,
args.Version
);
var apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
if (apiKeyResult?.ApiKey != null)
{
args.ExtraProperties["api-key"] = apiKeyResult.ApiKey;
}
if (apiKeyResult?.LicenseCode != null)
{
args.ExtraProperties["license-code"] = apiKeyResult.LicenseCode;
}
var context = new ProjectBuildContext(
templateInfo,
templateFile,
args
);
ProjectBuildPipelineBuilder.Build(context).Execute();
if (!templateInfo.DocumentUrl.IsNullOrEmpty())
{
Logger.LogInformation("Check out the documents at " + templateInfo.DocumentUrl);
}
// Exclude unwanted or known options.
var options = args.ExtraProperties
.Where(x => !x.Key.Equals(CliConsts.Command, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals("tiered", StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.DatabaseProvider.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.DatabaseProvider.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.OutputFolder.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.OutputFolder.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.UiFramework.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.UiFramework.Short, StringComparison.InvariantCultureIgnoreCase))
.Where(x => !x.Key.Equals(NewCommand.Options.Version.Long, StringComparison.InvariantCultureIgnoreCase) &&
!x.Key.Equals(NewCommand.Options.Version.Short, StringComparison.InvariantCultureIgnoreCase))
.Select(x => x.Key).ToList();
await CliAnalyticsCollect.CollectAsync(new CliAnalyticsCollectInputDto
{
Tool = Options.ToolName,
Command = args.ExtraProperties.ContainsKey(CliConsts.Command) ? args.ExtraProperties[CliConsts.Command] : "",
DatabaseProvider = args.DatabaseProvider.ToProviderName(),
IsTiered = args.ExtraProperties.ContainsKey("tiered"),
UiFramework = args.UiFramework.ToFrameworkName(),
Options = JsonSerializer.Serialize(options),
ProjectName = args.SolutionName.FullName,
TemplateName = args.TemplateName,
TemplateVersion = templateFile.Version
});
return(new ProjectBuildResult(context.Result.ZipContent, args.SolutionName.ProjectName));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Dictionary <string, IStacSummaryItem> summaries = (Dictionary <string, IStacSummaryItem>)value;
serializer.Serialize(writer, summaries.Where(k => k.Value != null).ToDictionary(k => k.Key, k => k.Value.AsJToken));
}
public static JsonString SerializeToJson <T>(this T source) => new JsonString(JsonSerializer.Serialize(source));
public string GetCode() => JsonSerializer.Serialize(this);
public string Serialize <T>(T value) => JsonSerializer.Serialize(value, _options);
public string ToString(object value, Type valueType)
{
return JsonSerializer.Serialize(value, valueType);
}
public override string ToString()
{
return(JsonSerializer.Serialize(this));
}
public void UpdateData(ProductDetailModel model)
{
List <string> sqls = new List <string>();
List <SqlParameter[]> cmdParms = new List <SqlParameter[]>();
#region WineProduct
StringBuilder str = new StringBuilder();
str.AppendLine("Update WineProduct set");
str.AppendLine(" WineCategoryID =@WineCategoryID ");
str.AppendLine(" ,ProductYear=@ProductYear");
str.AppendLine(" ,Price=@Price");
str.AppendLine(" ,Describle=@Describle");
str.AppendLine(" ,Region=@Region");
str.AppendLine(" ,IsDelete=@IsDelete");
str.AppendLine(" ,UpdateUser=@UpdateUser");
str.AppendLine(" ,UpdateTime=getdate()");
str.AppendLine(" Where WineID = @WineID");
SqlParameter[] paras = new SqlParameter[8];
paras[0] = new SqlParameter("@WineID", model.WineID);
paras[1] = new SqlParameter("@WineCategoryID", model.WineCategoryID);
paras[2] = new SqlParameter("@ProductYear", model.ProductYear);
paras[3] = new SqlParameter("@Price", model.Price);
JsonSerializer myJsonSerializer = new JsonSerializer();
string describle = myJsonSerializer.Serialize <List <ProductDescribleModel> >(model.Describle);
paras[4] = new SqlParameter("@Describle", describle);
paras[5] = new SqlParameter("@Region", Common.VariableConvert.ConvertStringToDBValue(model.Region));
paras[6] = new SqlParameter("@IsDelete", Common.VariableConvert.BitConverter(model.IsDelete));
paras[7] = new SqlParameter("@UpdateUser", Common.VariableConvert.ConvertStringToDBValue(model.UpdateUser));
sqls.Add(str.ToString());
cmdParms.Add(paras);
#endregion
#region WineImage
//delete all data
str = new StringBuilder();
str.AppendLine("Delete from WineImage where WineID = @WineID");
paras = new SqlParameter[1];
paras[0] = new SqlParameter("@WineID", model.WineID);
sqls.Add(str.ToString());
cmdParms.Add(paras);
//insert new data
for (int i = 0; i < model.WineImages.Count; i++)
{
str = new StringBuilder();
str.AppendLine("Insert into WineImage");
str.AppendLine(" (WineID, Url, ImageType) ");
str.AppendLine(" Values (@WineID, @Url, @ImageType);");
paras = new SqlParameter[3];
paras[0] = new SqlParameter("@WineID", model.WineID);
paras[1] = new SqlParameter("@Url", Common.VariableConvert.ConvertStringToDBValue(model.WineImages[i].Url));
paras[2] = new SqlParameter("@ImageType", model.WineImages[i].ImageType);
sqls.Add(str.ToString());
cmdParms.Add(paras);
}
#endregion
SqlAccess mySqlAccess = new SqlAccess();
mySqlAccess.ExecuteNonQuerys(sqls, cmdParms);
}
public static void SendReturnMessage(WebSocket socket, GameReturn msg)
{
string json = JsonSerializer.Serialize(msg);
WebSocketClient.SendMessage(socket, json);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var identityValue = value?.GetType().GetProperty("Value")?.GetValue(value, null);
serializer.Serialize(writer, identityValue);
}
public void SerializeGoogleGeoCode()
{
string json = @"{
""name"": ""1600 Amphitheatre Parkway, Mountain View, CA, USA"",
""Status"": {
""code"": 200,
""request"": ""geocode""
},
""Placemark"": [
{
""address"": ""1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA"",
""AddressDetails"": {
""Country"": {
""CountryNameCode"": ""US"",
""AdministrativeArea"": {
""AdministrativeAreaName"": ""CA"",
""SubAdministrativeArea"": {
""SubAdministrativeAreaName"": ""Santa Clara"",
""Locality"": {
""LocalityName"": ""Mountain View"",
""Thoroughfare"": {
""ThoroughfareName"": ""1600 Amphitheatre Pkwy""
},
""PostalCode"": {
""PostalCodeNumber"": ""94043""
}
}
}
}
},
""Accuracy"": 8
},
""Point"": {
""coordinates"": [-122.083739, 37.423021, 0]
}
}
]
}";
GoogleMapGeocoderStructure jsonGoogleMapGeocoder = JsonConvert.DeserializeObject <GoogleMapGeocoderStructure>(json);
MemoryStream ms = new MemoryStream();
BsonWriter writer = new BsonWriter(ms);
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, jsonGoogleMapGeocoder);
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
GoogleMapGeocoderStructure bsonGoogleMapGeocoder = (GoogleMapGeocoderStructure)serializer.Deserialize(reader, typeof(GoogleMapGeocoderStructure));
Assert.IsNotNull(bsonGoogleMapGeocoder);
Assert.AreEqual("1600 Amphitheatre Parkway, Mountain View, CA, USA", bsonGoogleMapGeocoder.Name);
Assert.AreEqual("200", bsonGoogleMapGeocoder.Status.Code);
Assert.AreEqual("geocode", bsonGoogleMapGeocoder.Status.Request);
IList <Placemark> placemarks = bsonGoogleMapGeocoder.Placemark;
Assert.IsNotNull(placemarks);
Assert.AreEqual(1, placemarks.Count);
Placemark placemark = placemarks[0];
Assert.AreEqual("1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA", placemark.Address);
Assert.AreEqual(8, placemark.AddressDetails.Accuracy);
Assert.AreEqual("US", placemark.AddressDetails.Country.CountryNameCode);
Assert.AreEqual("CA", placemark.AddressDetails.Country.AdministrativeArea.AdministrativeAreaName);
Assert.AreEqual("Santa Clara", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.SubAdministrativeAreaName);
Assert.AreEqual("Mountain View", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.LocalityName);
Assert.AreEqual("1600 Amphitheatre Pkwy", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.Thoroughfare.ThoroughfareName);
Assert.AreEqual("94043", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.PostalCode.PostalCodeNumber);
Assert.AreEqual(-122.083739m, placemark.Point.Coordinates[0]);
Assert.AreEqual(37.423021m, placemark.Point.Coordinates[1]);
Assert.AreEqual(0m, placemark.Point.Coordinates[2]);
}
/// <summary>
/// This method is used to write the json in order to balance the date time of the json information given by the json properties.
///
/// Precondition: none
/// Postcondition: none
/// </summary>
/// <param name="writer">passed in to write</param>
/// <param name="value">passed in for the value</param>
/// <param name="serializer">passed in to serialize the json</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
serializer.Serialize(writer, value);
}
public void WriteValue(object value)
{
serializer.Serialize(writer, value);
}
public static IHtmlContent JsonEncode(this string source) => new JsonString(JsonSerializer.Serialize(source));
public override string Serialize(object obj, ISerializerOptionsAbstract options)
{
return(JsonSerializer.Serialize(obj, (JsonSerializerOptions)options.ShimSpecificOptions));
}
private static StringContent CreateStringContent <TRequest>(TRequest content)
{
return(new StringContent(JsonSerializer.Serialize(content), Encoding.UTF8,
MediaTypeNames.Application.Json));
}
public override void Write(Utf8JsonWriter writer, PictureInfo value, JsonSerializerOptions options)
{
JsonSerializer.Serialize(writer, value);
}
public async void QueryWiFiProbes()
{
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{username}:{password}")));
var filename = Methods.GetFilePath(CONSTANT.FILENAME_HOME_DEVICES);
try
{
//open file and -> list of devices from Raspberry if the file exists
if (File.Exists(filename))
{
var result = await Methods.OpenExistingFile(filename);
WiFiDevice.WellKnownDevices = JsonSerializer.Deserialize <List <WiFiDevice> >(result).ToList();
}
else
{
double unixTimestamp = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
//following will happen only if there is no file on Raspberry and the list will be loaded from the environment variables
WiFiDevice.WellKnownDevices.ForEach(x => x.StatusUnixTime = unixTimestamp);
}
}
catch (Exception e)
{
Console.WriteLine($"open file {e}");
}
await SendMacAddressToCosmos(WiFiDevice.WellKnownDevices);
bool isAnyDeviceChanged = true;
var UnknownDevices = new List <WiFiDevice>();
while (true)
{
double unixTimestamp = METHOD.DateTimeToUnixTimestamp(DateTime.UtcNow);
double timeOffset = METHOD.DateTimeTZ().Offset.TotalHours;
//if there are some items from PowerApps then proceed
if (WiFiDevicesFromPowerApps.Any())
{
//Add, Remove or Change WiFiDevices list according to WiFiDevices From PowerApps
WiFiDevice.WellKnownDevices = AddRemoveChangeDevices(WiFiDevicesFromPowerApps, WiFiDevice.WellKnownDevices);
WiFiDevicesFromPowerApps.Clear();
//send all devices to CosmosDB
await SendMacAddressToCosmos(WiFiDevice.WellKnownDevices);
}
//prepare multimac query
//create a list of the MAC Addresses for multimac query
List <string> deviceMacs = new List <string>();
WiFiDevice.WellKnownDevices.ForEach(x => deviceMacs.Add(x.MacAddress));
string jsonMacAddresses = JsonSerializer.Serialize(deviceMacs);
string urlMultiMac = $"{urlKismet}/devices/multimac/devices.json";
string jsonContentFieldsMac = "json={\"fields\":" + jsonFields + ",\"devices\":" + jsonMacAddresses + "}";
List <WiFiDevice> KismetKnownDevices = await GetDevices(urlMultiMac, jsonContentFieldsMac);
//clear devices list.
WiFiDevicesToPowerApps.Clear();
//building list of the local devices which are last seen
foreach (var knownDevice in WiFiDevice.WellKnownDevices)
{
foreach (var kismet in KismetKnownDevices)
{
if (knownDevice.MacAddress == kismet.MacAddress)
{
knownDevice.LastUnixTime = kismet.LastUnixTime;
knownDevice.LastSignal = kismet.LastSignal;
knownDevice.SignalType = kismet.SignalType;
knownDevice.SSID = kismet.SSID;
knownDevice.WiFiName = kismet.ProbedSSID;
if (kismet.SignalType.Contains("Wi-Fi"))
{
knownDevice.AccessPoint = WiFiDevice.WellKnownDevices.Where(x => x.MacAddress == kismet.LastBSSID).Select(x => x.DeviceName).DefaultIfEmpty("No AP").First();
if (string.IsNullOrEmpty(knownDevice.WiFiName) || knownDevice.WiFiName == "0")
{
knownDevice.WiFiName = WiFiDevice.WellKnownDevices.Where(x => x.MacAddress == kismet.LastBSSID).Select(x => x.SSID).DefaultIfEmpty("No AP").First();
}
}
break;
}
}
//checking active devices and setting Active/NonActive statuses. Each device can have individual timewindow
knownDevice.IsChanged = false; //this is just for debugging, no other reason
var durationUntilNotActive = (unixTimestamp - knownDevice.LastUnixTime) / 60; //timestamp in minutes
knownDevice.IsPresent = durationUntilNotActive < knownDevice.ActiveDuration;
if (knownDevice.IsPresent && !knownDevice.StatusChange)
{
knownDevice.StatusUnixTime = unixTimestamp;
knownDevice.StatusChange = true;
isAnyDeviceChanged = true;
knownDevice.IsChanged = true;
}
if (!knownDevice.IsPresent && knownDevice.StatusChange)
{
knownDevice.StatusUnixTime = knownDevice.LastUnixTime;
knownDevice.StatusChange = false;
isAnyDeviceChanged = true;
knownDevice.IsChanged = true;
}
//following list WiFiDevicesToPowerApps is used to send minimal data to PowerApps (sending only userdevices)
//this list will be sent as a response after PowerApps asks something or refreshing it's data
if (knownDevice.DeviceType != WiFiDevice.DEVICE)
{
WiFiDevicesToPowerApps.Add(new Localdevice()
{
DeviceOwner = knownDevice.DeviceOwner,
DeviceName = knownDevice.DeviceName,
DeviceType = knownDevice.DeviceType,
IsPresent = knownDevice.IsPresent,
StatusFrom = METHOD.UnixTimeStampToDateTime(knownDevice.StatusUnixTime),
ActiveDuration = knownDevice.ActiveDuration,
MacAddress = knownDevice.MacAddress,
SignalType = knownDevice.SignalType,
IsChanged = knownDevice.IsChanged
});
}
//build a list with the names who is expected to track
//this list will be sent through Azure Functions to the owners e-mail
if (knownDevice.DeviceType == WiFiDevice.MOBILE || knownDevice.DeviceType == WiFiDevice.WATCH || knownDevice.DeviceType == WiFiDevice.CAR)
{
//to be sure that every person is listed just once
if (!WiFiDevicesWhoIsChanged.Any(x => x.DeviceOwner == knownDevice.DeviceOwner) || !WiFiDevicesWhoIsChanged.Any())
{
WiFiDevicesWhoIsChanged.Add(new Localdevice()
{
DeviceOwner = knownDevice.DeviceOwner,
DeviceName = knownDevice.DeviceName,
IsPresent = knownDevice.IsPresent,
StatusFrom = METHOD.UnixTimeStampToDateTime(knownDevice.StatusUnixTime),
SignalType = knownDevice.SignalType,
IsChanged = knownDevice.IsChanged
});
}
}
}
//update the list of the correct statuses, are they home or away
foreach (var item in WiFiDevicesWhoIsChanged)
{
item.IsChanged = false;
foreach (var device in WiFiDevicesToPowerApps)
{
if (item.DeviceOwner == device.DeviceOwner && (device.DeviceType == WiFiDevice.MOBILE || device.DeviceType == WiFiDevice.WATCH || device.DeviceType == WiFiDevice.CAR))
{
if (device.IsChanged)
{
item.IsChanged = device.IsChanged;
item.DeviceName = device.DeviceName;
item.StatusFrom = device.StatusFrom.AddHours(timeOffset);
item.SignalType = device.SignalType;
item.IsPresent = device.IsPresent;
}
//if device is exist and has'nt been changed, then mark it as unchanged and move to next item
//if device is not exist (not seen) but has been changed then mark it as unchanged and move to next item = do not notify leaving devices
//this is XOR
if (device.IsPresent ^ device.IsChanged)
{
item.IsChanged = false;
break;
}
}
}
}
//save the data locally into Raspberry
var jsonString = JsonSerializer.Serialize(WiFiDevice.WellKnownDevices);
await Methods.SaveStringToLocalFile(filename, jsonString);
//send an e-mail only if someone has arrived at home or left the home
if (WiFiDevicesWhoIsChanged.Any(x => x.IsChanged))
{
string status = "Look who is at home:\n\n";
WiFiDevicesWhoIsChanged.ForEach(x => status += $"{(x.IsPresent ? x.DeviceOwner + " " + x.DeviceName + " at home from" : x.DeviceOwner + " not seen since")} {x.StatusFrom:HH:mm dd.MM.yyyy} \n ");
var x = WiFiDevicesWhoIsChanged.First(x => x.IsChanged);
string whoChanged = $"{(x.IsPresent ? x.DeviceOwner + " at home " : x.DeviceOwner + " not seen since")} {x.StatusFrom:HH:mm dd.MM.yyyy}";
_sendListData = new SendDataAzure();
TelemetryDataClass.SourceInfo = $"{whoChanged}";
//send data to CosmosDB
var monitorData = new
{
DeviceID = "HomeController",
TelemetryDataClass.SourceInfo,
status,
DateAndTime = METHOD.DateTimeTZ().DateTime,
isHomeSecured = true
};
await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output");
}
//if any mobile phone or watch is present then someone is at home
IsAnyMobileAtHome = WiFiDevice.WellKnownDevices.Any(x => x.IsPresent && (x.DeviceType == WiFiDevice.MOBILE || x.DeviceType == WiFiDevice.WATCH || x.DeviceType == WiFiDevice.CAR));
//if security mode automatic and home secured then unsecure home if any known mobile device is seen
if (IsAnyMobileAtHome && TelemetryDataClass.isHomeSecured && !SomeoneAtHome.IsSecurityManuallyOn)
{
SomeoneAtHome.SomeoneAtHomeChanged();
}
#region Known Device Listing, only for debugging
//for local debugging only show the active/non active devices in console window
if (isAnyDeviceChanged)
{
isAnyDeviceChanged = false;
var sortedList = WiFiDevice.WellKnownDevices.OrderByDescending(y => y.IsPresent).ThenBy(w => w.AccessPoint).ThenBy(z => z.SignalType).ThenBy(x => x.DeviceName).ToList();
Console.WriteLine();
Console.WriteLine($"All known devices at: {METHOD.DateTimeTZ().DateTime:G}");
Console.WriteLine();
Console.WriteLine($" | From | Status | Device | WiFi network | AccessPoint | SignalType");
Console.WriteLine($" | ------ | ------- | -------- | ----- | ----- | -------- ");
foreach (var device in sortedList)
{
if (device.LastUnixTime > 0 && device.SignalType != "Wi-Fi AP" && device.DeviceOwner != "Unknown" && device.DeviceType != WiFiDevice.DEVICE) //show only my own ever seen LocalUserDevices devices
{
Console.WriteLine($" {(device.IsChanged ? "1" : " ")} " +
$"| {METHOD.UnixTimeStampToDateTime(device.StatusUnixTime).AddHours(timeOffset):T} " +
$"| {(device.IsPresent ? "Active " : "Not Act")} " +
$"| {device.DeviceName}{"".PadRight(26 - (device.DeviceName.Length > 26 ? 26 : device.DeviceName.Length))}" +
$"| {device.WiFiName}{"".PadRight(26 - (!string.IsNullOrEmpty(device.WiFiName) ? (device.WiFiName.Length > 26 ? 26 : device.WiFiName.Length) : 0))}" +
$"| {device.AccessPoint}{"".PadRight(26 - (!string.IsNullOrEmpty(device.AccessPoint) ? (device.AccessPoint.Length > 26 ? 26 : device.AccessPoint.Length) : 0))}" +
$"| {device.SignalType} ");
}
}
Console.WriteLine();
}
#endregion
#region Unknown Devices Debugging
//prepare last active devices query
string urlLastActive = $"{urlKismet}/devices/last-time/{CONSTANT.ACTIVE_DEVICES_IN_LAST}/devices.json";
string jsonContentFields = "json={\"fields\":" + jsonFields + "}";
List <WiFiDevice> KismetActiveDevices = await GetDevices(urlLastActive, jsonContentFields);
//removing all known devices from the last seen devices list
//known devices are all locally registered devices in the list WiFiDevice.WifiDevices
var tempDelList = new List <WiFiDevice>();
var AllActiveDevices = new List <WiFiDevice>(KismetActiveDevices);
foreach (var kismet in KismetActiveDevices)
{
foreach (var knownDevice in WiFiDevice.WellKnownDevices)
{
if (kismet.MacAddress == knownDevice.MacAddress || kismet.LastSignal < CONSTANT.SIGNAL_TRESHOLD || (kismet.CommonName == kismet.MacAddress && kismet.Manufacture == "Unknown"))
{
tempDelList.Add(kismet);
break;
}
}
}
KismetActiveDevices.RemoveAll(i => tempDelList.Contains(i));
//adding new members to the close devices list
if (KismetActiveDevices.Any())
{
var tempAddList = new List <WiFiDevice>();
bool isNewItem = true;
foreach (var kismet in KismetActiveDevices)
{
foreach (var unknownDevice in UnknownDevices)
{
if (kismet.MacAddress == unknownDevice.MacAddress)
{
unknownDevice.Count++;
unknownDevice.LastUnixTime = kismet.LastUnixTime;
unknownDevice.WiFiName = kismet.ProbedSSID;
if (kismet.SignalType.Contains("Wi-Fi"))
{
//get device AccessPoint and WIFI network names from Kismet (if reported by device)
List <WiFiDevice> KismetOneMac = new List <WiFiDevice>();
string urlOneMac = $"{urlKismet}/devices/by-mac/{kismet.MacAddress}/devices.json";
KismetOneMac = await GetDevices(urlOneMac, jsonContentFields);
//have to check KismetOneMac list because sometimes it is empty
if (KismetOneMac.Any())
{
unknownDevice.AccessPoint = AllActiveDevices.Where(x => x.MacAddress == KismetOneMac.First().LastBSSID).Select(x => x.BaseName).DefaultIfEmpty("No AP").First();
if (string.IsNullOrEmpty(kismet.ProbedSSID) || unknownDevice.WiFiName == "0")
{
unknownDevice.WiFiName = AllActiveDevices.Where(x => x.MacAddress == KismetOneMac.First().LastBSSID).Select(x => x.SSID).DefaultIfEmpty("No AP").First();
}
}
}
isNewItem = false;
break;
}
else
{
isNewItem = true;
}
}
if (isNewItem)
{
tempAddList.Add(kismet);
}
}
UnknownDevices.AddRange(tempAddList.ToArray());
UnknownDevices.RemoveAll(x => (unixTimestamp - x.LastUnixTime) / 60 > 120); //remove all entries older that 2 hour
//local debugging: show the devices list in console only if some device has been added
if (tempAddList.Any() && UnknownDevices.Any())
{
var sortedList = UnknownDevices.OrderBy(x => x.SignalType).ThenByDescending(y => y.LastUnixTime).ToList();
Console.WriteLine();
Console.WriteLine($"All unknown devices at: {METHOD.DateTimeTZ().DateTime:G}");
Console.WriteLine();
Console.WriteLine($"dB | First | Last | Mac Address |Count | SignalType | WiFi network | AccessPoint | Common Name | Manufacturer ");
Console.WriteLine($" - | ---- | ---- | ----------- | --- | ---------- | --------- | --------- | ----------- | ----------- ");
foreach (var device in sortedList)
{
Console.WriteLine($"{device.LastSignal}{"".PadRight(device.LastSignal < 0 ? 1 : 3)}" +
$"| {METHOD.UnixTimeStampToDateTime(device.FirstUnixTime).AddHours(timeOffset):t} " +
$"| {METHOD.UnixTimeStampToDateTime(device.LastUnixTime).AddHours(timeOffset):t} " +
$"| {device.MacAddress} " +
$"| {device.Count}{"".PadRight(device.Count < 10 ? 3 : device.Count < 100 ? 2 : 1)} " +
$"| {device.SignalType}{"".PadRight(14 - (!string.IsNullOrEmpty(device.SignalType) ? (device.SignalType.Length > 14 ? 14 : device.SignalType.Length) : 0))}" +
$"| {device.WiFiName}{"".PadRight(26 - (!string.IsNullOrEmpty(device.WiFiName) ? (device.WiFiName.Length > 26 ? 26 : device.WiFiName.Length) : 0))}" +
$"| {device.AccessPoint}{"".PadRight(26 - (!string.IsNullOrEmpty(device.AccessPoint) ? (device.AccessPoint.Length > 26 ? 26 : device.AccessPoint.Length) : 0))}" +
$"| {device.CommonName}{"".PadRight(19 - (!string.IsNullOrEmpty(device.CommonName) ? (device.CommonName.Length > 19 ? 19 : device.CommonName.Length) : 0))}" +
$"| {device.Manufacture}");
}
Console.WriteLine();
}
}
#endregion
await Task.Delay(TimeSpan.FromSeconds(60)); //check statuses every 10 millisecond
}
}
public static void VerifyTypeFail()
{
Assert.Throws <ArgumentException>(() => JsonSerializer.Serialize(1, typeof(string)));
}
public void Basic_Mapper()
{
var mapper = CreateMapper();
var obj = CreateModel();
var doc = mapper.ToDocument(obj);
var json = JsonSerializer.Serialize(doc, true);
// test read-only
Assert.AreEqual(obj.MyReadOnly, doc["my_read_only"].AsString);
var nobj = mapper.ToObject <MyClass>(doc);
// compare object to document
Assert.AreEqual(doc["_id"].AsInt32, obj.MyId);
Assert.AreEqual(doc["MY-STRING"].AsString, obj.MyString);
Assert.AreEqual(doc["my_guid"].AsGuid, obj.MyGuid);
// compare 2 objects
Assert.AreEqual(obj.MyId, nobj.MyId);
Assert.AreEqual(obj.MyString, nobj.MyString);
Assert.AreEqual(obj.MyGuid, nobj.MyGuid);
Assert.AreEqual(obj.MyDateTime.ToString(), nobj.MyDateTime.ToString());
Assert.AreEqual(obj.MyDateTimeNullable, nobj.MyDateTimeNullable);
Assert.AreEqual(obj.MyIntNullable, nobj.MyIntNullable);
Assert.AreEqual(obj.MyEnumProp, nobj.MyEnumProp);
Assert.AreEqual(obj.MyChar, nobj.MyChar);
Assert.AreEqual(obj.MyByte, nobj.MyByte);
Assert.AreEqual(obj.MySByte, nobj.MySByte);
Assert.AreEqual(obj.MyField, nobj.MyField);
Assert.AreEqual(obj.MyTimespan, nobj.MyTimespan);
Assert.AreEqual(obj.MyDecimal, nobj.MyDecimal);
Assert.AreEqual(obj.MyUri, nobj.MyUri);
// list
Assert.AreEqual(obj.MyStringArray[0], nobj.MyStringArray[0]);
Assert.AreEqual(obj.MyStringArray[1], nobj.MyStringArray[1]);
Assert.AreEqual(obj.MyStringEnumerable.First(), nobj.MyStringEnumerable.First());
Assert.AreEqual(obj.MyStringEnumerable.Take(1).First(), nobj.MyStringEnumerable.Take(1).First());
Assert.AreEqual(true, obj.CustomStringEnumerable.SequenceEqual(nobj.CustomStringEnumerable));
Assert.AreEqual(obj.MyDict[2], nobj.MyDict[2]);
Assert.AreEqual(obj.MyDictEnum[StringComparison.Ordinal], nobj.MyDictEnum[StringComparison.Ordinal]);
// list of structs
Assert.AreEqual(obj.MyCollectionPoint.First(), nobj.MyCollectionPoint.First());
Assert.AreEqual(obj.MyListPoint.First(), nobj.MyListPoint.First());
Assert.AreEqual(obj.MyEnumerablePoint.First(), nobj.MyEnumerablePoint.First());
// interfaces
Assert.AreEqual(obj.MyInterface.Name, nobj.MyInterface.Name);
Assert.AreEqual(obj.MyListInterface[0].Name, nobj.MyListInterface[0].Name);
Assert.AreEqual(obj.MyIListInterface[0].Name, nobj.MyIListInterface[0].Name);
// objects
Assert.AreEqual(obj.MyObjectString, nobj.MyObjectString);
Assert.AreEqual(obj.MyObjectInt, nobj.MyObjectInt);
Assert.AreEqual((obj.MyObjectImpl as MyImpl).Name, (nobj.MyObjectImpl as MyImpl).Name);
Assert.AreEqual(obj.MyObjectList[0], obj.MyObjectList[0]);
Assert.AreEqual(obj.MyObjectList[1], obj.MyObjectList[1]);
Assert.AreEqual(obj.MyObjectList[3], obj.MyObjectList[3]);
}
/// <summary>
/// Ensures there is a valid SlugCI Config file and updates it if necessary OR creates it.
/// </summary>
/// <returns></returns>
private bool ProcessSlugCIConfigFile()
{
SlugCIConfig slugCiConfig = SlugCIConfig;
if (slugCiConfig == null)
{
EnsureExistingDirectory(CISession.SlugCIPath);
slugCiConfig = new SlugCIConfig();
slugCiConfig.DeployToVersionedFolder = true;
}
// Make a copy that we will compare against.
SlugCIConfig origSlugCiConfig = slugCiConfig.Copy();
// Ensure the version of the config file layout is set to most current. We do this after the copy, so we can
// detect changes in the file layout, fields, etc.
slugCiConfig.ConfigStructureVersion = SlugCIConfig.CONFIG_STRUCTURE_VERSION;
bool updateProjectAdd = false;
bool hasCopyDeployMethod = false;
// Now go thru the Visual Studio Projects and update the config
foreach (VisualStudioProject project in Projects)
{
SlugCIProject slugCIProject = slugCiConfig.GetProjectByName(project.Name);
// New Visual Studio project that does not exist in SlugCIConfig
if (slugCIProject == null)
{
slugCIProject = AddSlugCIProject(slugCiConfig, project);
}
if (slugCIProject.Deploy == SlugCIDeployMethod.Copy)
{
hasCopyDeployMethod = true;
}
}
// Ensure Deploy Roots have values if at least one of the projects has a deploy method of Copy
if (hasCopyDeployMethod)
{
foreach (PublishTargetEnum value in Enum.GetValues(typeof(PublishTargetEnum)))
{
ValidateDeployFolders(value, slugCiConfig);
}
}
// Add Angular Projects
ProcessAngularProjects(slugCiConfig);
// Determine if we need to save new config.
if (origSlugCiConfig != slugCiConfig)
{
string json = JsonSerializer.Serialize <SlugCIConfig>(slugCiConfig, SlugCIConfig.SerializerOptions());
File.WriteAllText(CISession.SlugCIFileName, json);
AOT_Success("SlugCIConfig file updated to latest version / values");
SlugCIConfig = GetSlugCIConfig(true);
if (updateProjectAdd)
{
Logger.Warn("The file: {0} was updated. One ore more projects were added. Ensure they have the correct Deploy setting.", CISession.SlugCIFileName);
}
}
return(true);
}
public void SerializeDefaultOptions()
{
var jsonString = JsonSerializer.Serialize(CreateBoard());
Assert.Equal("\"WSH".PadRight(101, ' ') + "\"", jsonString);
}
public static void ToStringNullTypeFail()
{
Assert.Throws <ArgumentNullException>(() => JsonSerializer.Serialize(new object(), (Type)null));
}
public static void editSubscription()
{
//This function can edit a subscription
string valId, valMonthPrice, replace, valYearSubscription = "";
int id = 0;
double dMonthPrice = 0.0;
string subscriptionDetails = File.ReadAllText("subscriptions.json");
List <Subscription> subscriptionDetail = JsonSerializer.Deserialize <List <Subscription> >(subscriptionDetails);
for (int i = 0; i < subscriptionDetail.Count; i++)
{
Console.WriteLine("ID: " + subscriptionDetail[i].Id);
Console.WriteLine("Name: " + subscriptionDetail[i].Name);
Console.WriteLine("\n===================================================================================\n");
}
Console.WriteLine("Enter the id of the subscription you want to manage: ");
valId = Console.ReadLine();
id = Convert.ToInt32(valId);
var searchedSubscription = subscriptionDetail.FirstOrDefault(m => m.Id == id);
Console.WriteLine("ID: " + searchedSubscription.Id);
Console.WriteLine("Name: " + searchedSubscription.Name);
Console.WriteLine("Price per month: " + searchedSubscription.MonthPrice);
if (searchedSubscription.YearSubscription)
{
Console.WriteLine("Year subscription: Yes");
Console.WriteLine("Price per year: " + ((searchedSubscription.MonthPrice * 12) - 15));
}
else
{
Console.WriteLine("Year subscription: No");
}
Console.WriteLine("Enter a new subscription name: ");
searchedSubscription.Name = Console.ReadLine();
Console.WriteLine("Enter a new price per month: ");
valMonthPrice = Console.ReadLine();
replace = valMonthPrice.Replace(".", ",");
dMonthPrice = Convert.ToDouble(replace);
searchedSubscription.MonthPrice = dMonthPrice;
Console.WriteLine("Year subscription: Yes: Y or No: N");
valYearSubscription = Console.ReadLine();
if (valYearSubscription == "Y" || valYearSubscription == "y")
{
searchedSubscription.YearSubscription = true;
}
else
{
searchedSubscription.YearSubscription = false;
}
string resultJson = JsonSerializer.Serialize <List <Subscription> >(subscriptionDetail);
File.WriteAllText("subscriptions.json", resultJson);
Console.WriteLine("Changes successfully saved.");
}
