public LspContractResolver(
ImmutableArray <CompletionItemKind> completionItemKinds,
ImmutableArray <CompletionItemTag> completionItemTags,
ImmutableArray <SymbolKind> documentSymbolKinds,
ImmutableArray <SymbolKind> workspaceSymbolKinds,
ImmutableArray <SymbolTag> documentSymbolTags,
ImmutableArray <SymbolTag> workspaceSymbolTags,
ImmutableArray <DiagnosticTag> diagnosticTags,
ImmutableArray <CodeActionKind> codeActionKinds,
ImmutableArray <SemanticTokenType> semanticTokenType,
ImmutableArray <SemanticTokenModifier> semanticTokenModifier
)
{
_completionItemKinds = completionItemKinds;
_completionItemTags = completionItemTags;
_documentSymbolKinds = documentSymbolKinds;
_workspaceSymbolKinds = workspaceSymbolKinds;
_documentSymbolTags = documentSymbolTags;
_workspaceSymbolTags = workspaceSymbolTags;
_diagnosticTags = diagnosticTags;
_codeActionKinds = codeActionKinds;
_semanticTokenType = semanticTokenType;
_semanticTokenModifier = semanticTokenModifier;
NamingStrategy = new CamelCaseNamingStrategy(true, false, true);
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var contract = base.CreateObjectContract(objectType);
var objectTypeInfo = objectType.GetTypeInfo();
if (TypeData <ExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo))
{
contract.ExtensionDataGetter = o => ((DirtyDictionary <string, object>)((ExtensibleObject)o).ExtensionData).GetDirtyItems().Select(p => new KeyValuePair <object, object>(p.Key, p.Value));
contract.ExtensionDataSetter = (o, k, v) => ((ExtensibleObject)o).ExtensionData[k] = v;
if (TypeData <DirtyExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo))
{
var idPropertyName = DirtyExtensibleObject.GetIdPropertyName(objectTypeInfo);
var backingFieldTypeInfo = GetBackingFieldInfo(objectType, idPropertyName)?.FieldInfo.FieldType.GetTypeInfo();
idPropertyName = CamelCaseNamingStrategy.GetPropertyName(idPropertyName, false);
var idProperty = contract.Properties.GetClosestMatchProperty(idPropertyName);
if (idProperty != null && (backingFieldTypeInfo == null || !backingFieldTypeInfo.IsGenericType || backingFieldTypeInfo.IsGenericTypeDefinition || backingFieldTypeInfo.GetGenericTypeDefinition() != TypeData.OpenNeverSerializeValueType))
{
idProperty.ShouldSerialize = o => ((IIdentifiable)o).Id != null;
}
ReadEntityAttributes(objectTypeInfo, contract);
}
}
return(contract);
}
public JsonDeserializer(NamingConvention namingConvention = NamingConvention.CamelHump)
{
_jsonSettings = new JsonSerializerSettings();
NamingStrategy selectedNamingStrategy;
switch (namingConvention)
{
case NamingConvention.CamelHump:
selectedNamingStrategy = new CamelCaseNamingStrategy(true, false);
break;
case NamingConvention.SnakeCase:
selectedNamingStrategy = new SnakeCaseNamingStrategy(true, false);
break;
default:
selectedNamingStrategy = new DefaultNamingStrategy();
break;
}
_jsonSettings.ContractResolver = new PrivateSetterContractResolver
{
NamingStrategy = selectedNamingStrategy
};
}
public static NewtonsoftJsonSerializer Create(JsonNamingStrategy namingStrategy)
{
Newtonsoft.Json.Serialization.NamingStrategy chosenStrategy;
switch (namingStrategy)
{
case JsonNamingStrategy.Default:
chosenStrategy = new DefaultNamingStrategy();
break;
case JsonNamingStrategy.CamelCase:
chosenStrategy = new CamelCaseNamingStrategy();
break;
case JsonNamingStrategy.SnakeCase:
chosenStrategy = new SnakeCaseNamingStrategy();
break;
default:
throw new ArgumentOutOfRangeException(
$"Unhandled JsonNamingStrategy: {namingStrategy}");
}
return(new NewtonsoftJsonSerializer(new Newtonsoft.Json.JsonSerializer()
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.None,
ContractResolver = new DefaultContractResolver()
{
NamingStrategy = chosenStrategy
}
}));
}
public NonCircularContractResolver(Type contractType)
{
_contractType = contractType;
NamingStrategy = new CamelCaseNamingStrategy {
OverrideSpecifiedNames = false
};
}
public void Given_FakeModel_When_ToOpenApiSchemas_Invoked_Then_It_Should_Return_Result()
{
var type = typeof(FakeModel);
var subType = typeof(FakeSubModel);
var enumType = typeof(FakeEnum);
var strategy = new CamelCaseNamingStrategy();
var schemas = OpenApiSchemaExtensions.ToOpenApiSchemas(type, strategy);
schemas.Count.Should().Be(3);
var schema = schemas[type.Name];
var subSchema = schemas[subType.Name];
var enumSchema = schemas[enumType.Name];
schema.Type.Should().Be("object");
schema.Properties["fakeProperty"].Type.Should().BeEquivalentTo("string");
schema.Properties["nullableInt"].Type.Should().BeEquivalentTo("integer");
schema.Properties["nullableInt"].Nullable.Should().BeTrue();
schema.Properties["subProperty"].Reference.Id.Should().BeEquivalentTo(subType.Name);
schema.Properties["enumProperty"].Reference.Id.Should().BeEquivalentTo(enumType.Name);
subSchema.Type.Should().Be("object");
subSchema.Properties["fakeSubModelProperty"].Type.Should().BeEquivalentTo("integer");
enumSchema.Type.Should().Be("string");
enumSchema.Enum.Count.Should().Be(2);
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var contract = base.CreateObjectContract(objectType);
var objectTypeInfo = objectType.GetTypeInfo();
if (TypeData <ExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo))
{
contract.ExtensionDataGetter = o => ((DirtyDictionary <string, object>)((ExtensibleObject)o).ExtensionData).GetDirtyItems().Select(p => new KeyValuePair <object, object>(p.Key, p.Value));
contract.ExtensionDataSetter = (o, k, v) => ((ExtensibleObject)o).ExtensionData[k] = v;
if (TypeData <DirtyExtensibleObject> .TypeInfo.IsAssignableFrom(objectTypeInfo))
{
var idPropertyName = DirtyExtensibleObject.GetIdPropertyName(objectTypeInfo);
var backingFieldTypeInfo = GetBackingFieldInfo(objectType, idPropertyName)?.FieldInfo.FieldType.GetTypeInfo();
idPropertyName = CamelCaseNamingStrategy.GetPropertyName(idPropertyName, false);
var property = contract.Properties.GetClosestMatchProperty(idPropertyName);
if (property != null && (backingFieldTypeInfo == null || !backingFieldTypeInfo.IsGenericType || backingFieldTypeInfo.IsGenericTypeDefinition || backingFieldTypeInfo.GetGenericTypeDefinition() != TypeData.OpenNeverSerializeValueType))
{
property.ShouldSerialize = o => ((IIdentifiable)o).Id != null;
}
var entityAttribute = objectTypeInfo.GetCustomAttribute <EntityAttribute>(false);
if (entityAttribute != null && !string.IsNullOrEmpty(entityAttribute.PropertiesToAlwaysSerialize))
{
var propertiesToAlwaysSerialize = entityAttribute.PropertiesToAlwaysSerialize.Split(',');
foreach (var propertyToAlwaysSerialize in propertiesToAlwaysSerialize)
{
property = contract.Properties.GetClosestMatchProperty(propertyToAlwaysSerialize);
var valueProvider = property.ValueProvider;
property.ShouldSerialize = o => valueProvider.GetValue(o) != null;
}
}
}
}
return(contract);
}
public StringEnumConverter(bool camelCaseText)
{
if (camelCaseText)
{
NamingStrategy = new CamelCaseNamingStrategy();
}
}
//P07
public static string GetCategoriesByProductsCount(ProductShopContext context)
{
var categories = context
.Categories
.OrderByDescending(c => c.CategoryProducts.Count)
.Select(c => new
{
Category = c.Name,
ProductsCount = c.CategoryProducts.Count,
AveragePrice = $"{c.CategoryProducts.Average(cp => cp.Product.Price):f2}",
TotalRevenue = $"{c.CategoryProducts.Sum(cp => cp.Product.Price):f2}"
});
DefaultContractResolver contractResolver = new DefaultContractResolver();
{
var namingStrategy = new CamelCaseNamingStrategy();
}
var jsonResult = JsonConvert.SerializeObject(categories, new JsonSerializerSettings()
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(jsonResult);
}
//P06
public static string GetSoldProducts(ProductShopContext context)
{
var usersWithSales = context
.Users
.Where(u => u.ProductsSold.Count > 0 &&
u.ProductsSold.Any(ps => ps.Buyer != null))
.OrderBy(u => u.LastName)
.ThenBy(u => u.FirstName)
.Include(u => u.ProductsSold)
.ToList();
var jsonExport = Mapper.Map <IEnumerable <User>, IEnumerable <UserWithSalesDto> >(usersWithSales);
DefaultContractResolver contractResolver = new DefaultContractResolver();
{
var namingStrategy = new CamelCaseNamingStrategy();
}
var jsonResult = JsonConvert.SerializeObject(jsonExport, new JsonSerializerSettings()
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(jsonResult);
}
public IEnumerable <FieldResponse> GetAllForForm(string id)
{
var result = new List <FieldResponse>();
foreach (var field in FieldProvider.GetAllFor(id))
{
if (!field.AutoGenerate)
{
continue;
}
var control = ControlMatcher.GetFor(field.Type, field.UIHints);
var embeddedFormId = FormProvider.GetAll().FirstOrDefault(f => f.Type == field.Type);
if (control == null && embeddedFormId == null)
{
continue;
}
result.Add(new FieldResponse
{
Id = field.Id,
Label = field.Label ?? Humanizer.Humanize(field.Id),
CamelCaseId = CamelCaseNamingStrategy.GetPropertyName(field.Id, false),
Control = control,
EmbeddedFormId = embeddedFormId?.Id,
IsSortable = field.IsSortable,
Group = field.Group,
});
}
return(result);
}
/// <summary>
/// Create an instance of CosmosSerializationOptions
/// with the default values for the Cosmos SDK
/// </summary>
public CosmosSerializationOptions()
{
this.IgnoreNullValues = false;
this.Indented = false;
this.PropertyNamingPolicy = CosmosPropertyNamingPolicy.Default;
this.camelCaseNamingStrategy = new CamelCaseNamingStrategy();
}
public void Given_OpenApiResponseWithBodyAttribute_When_ToOpenApiMediaType_Invoked_Then_It_Should_Return_Result(Type bodyType, string expected, bool items, bool additionalProperties, string underlyingType)
{
var statusCode = HttpStatusCode.OK;
var contentType = "application/json";
var attribute = new OpenApiResponseWithBodyAttribute(statusCode, contentType, bodyType);
var namingStrategy = new CamelCaseNamingStrategy();
var result = OpenApiPayloadAttributeExtensions.ToOpenApiMediaType(attribute, namingStrategy);
result.Schema.Type.Should().Be(expected);
result.Schema.Deprecated.Should().BeFalse();
if (items)
{
result.Schema.Items.Should().NotBeNull();
result.Schema.Items.Type.Should().Be(underlyingType);
}
else
{
result.Schema.Items.Should().BeNull();
}
if (additionalProperties)
{
result.Schema.AdditionalProperties.Should().NotBeNull();
result.Schema.AdditionalProperties.Type.Should().Be(underlyingType);
}
else
{
result.Schema.AdditionalProperties.Should().BeNull();
}
}
public SwaggerContractResolver(JsonSerializerSettings applicationSerializerSettings)
{
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = false
};
_applicationTypeConverter = new ApplicationTypeConverter(applicationSerializerSettings);
}
public NoteMeContractResolver()
{
NamingStrategy = new CamelCaseNamingStrategy();
IgnoreSerializableAttribute = true;
IgnoreSerializableInterface = true;
SerializeCompilerGeneratedMembers = true;
}
public ElasticApmContractResolver(IConfigurationReader configurationReader)
{
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = true, OverrideSpecifiedNames = true
};
_headerDictionarySanitizerConverter = new HeaderDictionarySanitizerConverter(configurationReader);
}
public void Resolve(string source, string excepted)
{
var strategy = new CamelCaseNamingStrategy();
var result = strategy.Resolve(source);
Assert.Equal(excepted, result);
}
public void Test()
{
CamelCaseNamingStrategy namingStrategy = new CamelCaseNamingStrategy(
processDictionaryKeys: true,
overrideSpecifiedNames: false
);
TestClass c = new TestClass {
Value = TestEnum.UpperCaseName
};
string json = JsonConvert.SerializeObject(
c,
new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = namingStrategy
},
Converters = new[]
{
new StringEnumConverter {
NamingStrategy = namingStrategy
}
}
}
);
Assert.AreEqual(@"{""value"":""UPPER_CASE_NAME""}", json);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var properties = base.CreateProperties(type, memberSerialization);
if (UseCamelCase)
{
NamingStrategy = new CamelCaseNamingStrategy(true, true);
}
if (!IncludeUnderscoreProperties)
{
properties = properties.Where(each => !each.PropertyName.StartsWith("_")).ToList();
}
if (IdPropertyAlwaysFirst && SortAlphabetically)
{
properties = properties.OrderByDescending(p => p.PropertyName.ToLower() == "id").ThenBy(each => each.PropertyName).ToList();
}
else if (IdPropertyAlwaysFirst)
{
properties = properties.OrderByDescending(p => p.PropertyName.ToLower() == "id").ToList();
}
else if (SortAlphabetically)
{
properties = properties.OrderByDescending(each => each.PropertyName).ToList();
}
return(properties);
}
public CustomContractWrapper()
{
if (_customJsonContract.UseCamelCaseNamingStrategy)
{
NamingStrategy = new CamelCaseNamingStrategy();
}
}
public OneRosterContractResolver(Type type)
{
Type = type;
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = true, OverrideSpecifiedNames = true
};
}
public void Given_OpenApiResponseWithBodyAttribute_With_Example_When_ToOpenApiMediaType_Invoked_Then_It_Should_Return_Result(Type example, int count)
{
var statusCode = HttpStatusCode.OK;
var contentType = "application/json";
var bodyType = typeof(object);
var attribute = new OpenApiResponseWithBodyAttribute(statusCode, contentType, bodyType)
{
Example = example,
};
var namingStrategy = new CamelCaseNamingStrategy();
var result = OpenApiPayloadAttributeExtensions.ToOpenApiMediaType(attribute, namingStrategy);
result.Examples.Should().NotBeNull();
result.Examples.Should().HaveCount(count);
if (count == 0)
{
return;
}
var instance = (dynamic)Activator.CreateInstance(example);
var examples = (IDictionary <string, OpenApiExample>)instance.Build(namingStrategy).Examples;
var first = examples.First().Value;
(result.Example as OpenApiString).Value.Should().Be((first.Value as OpenApiString).Value);
}
public void CamelNamingStrategyTest(string original, string expected)
{
CamelCaseNamingStrategy strategy = new CamelCaseNamingStrategy();
string modified = strategy.GetName(original);
Assert.AreEqual(expected, modified);
}
public InteractiveJsonContractResolver()
{
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = true,
OverrideSpecifiedNames = true
};
}
static JsonMessageSerializer()
{
ByteArrayConverter = new ByteArrayConverter();
ListJsonConverter = new ListJsonConverter();
CaseInsensitiveDictionaryJsonConverter = new CaseInsensitiveDictionaryJsonConverter();
InterfaceProxyConverter = new InterfaceProxyConverter();
MessageDataJsonConverter = new MessageDataJsonConverter();
StringDecimalConverter = new StringDecimalConverter();
var namingStrategy = new CamelCaseNamingStrategy();
DefaultContractResolver deserializerContractResolver = new JsonContractResolver(
ByteArrayConverter,
ListJsonConverter,
CaseInsensitiveDictionaryJsonConverter,
InterfaceProxyConverter,
MessageDataJsonConverter,
StringDecimalConverter)
{
NamingStrategy = namingStrategy
};
DefaultContractResolver serializerContractResolver =
new JsonContractResolver(ByteArrayConverter, MessageDataJsonConverter, StringDecimalConverter)
{
NamingStrategy = namingStrategy
};
_encoding = new Lazy <Encoding>(() => new UTF8Encoding(false, true), LazyThreadSafetyMode.PublicationOnly);
DeserializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore,
ObjectCreationHandling = ObjectCreationHandling.Auto,
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
ContractResolver = deserializerContractResolver,
TypeNameHandling = TypeNameHandling.None,
DateParseHandling = DateParseHandling.None,
DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind
};
SerializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore,
ObjectCreationHandling = ObjectCreationHandling.Auto,
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
ContractResolver = serializerContractResolver,
TypeNameHandling = TypeNameHandling.None,
DateParseHandling = DateParseHandling.None,
DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind
};
_deserializer = new Lazy <JsonSerializer>(() => JsonSerializer.Create(DeserializerSettings));
_serializer = new Lazy <JsonSerializer>(() => JsonSerializer.Create(SerializerSettings));
}
public NullToEmptyStringResolver() : base()
{
NamingStrategy = new CamelCaseNamingStrategy
{
ProcessDictionaryKeys = true,
OverrideSpecifiedNames = true
};
}
public ConiziDefaultResolver() : base()
{
NamingStrategy = new CamelCaseNamingStrategy
{
ProcessDictionaryKeys = true,
OverrideSpecifiedNames = true
};
}
public JsonFormatContractResolver(IDurableTypeSet durableTypes)
{
_durableTypes = durableTypes;
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = false
};
}
public ObjectPropertyResolver() : base()
{
NamingStrategy = new CamelCaseNamingStrategy
{
ProcessDictionaryKeys = true,
OverrideSpecifiedNames = true
};
}
public void CamelCaseNamingStrategyEquality()
{
var s1 = new CamelCaseNamingStrategy();
var s2 = new CamelCaseNamingStrategy();
Assert.IsTrue(s1.Equals(s2));
Assert.IsTrue(s1.GetHashCode() == s2.GetHashCode());
}
