void IRecordingService.Write(IProfile data)
{
var json = JsonConverterHelper.ToJson(data);
var currentLink = _apiService.CurrentLink;
_apiService.AddLinkInfo(currentLink, json);
}
private static bool IsStandardMessage(Type type, [NotNullWhen(true)] out MessageDescriptor?messageDescriptor)
{
if (!typeof(IMessage).IsAssignableFrom(type))
{
messageDescriptor = null;
return(false);
}
messageDescriptor = JsonConverterHelper.GetMessageDescriptor(type);
if (messageDescriptor == null)
{
return(false);
}
// Wrappers and well known types are handled by converters.
if (ServiceDescriptorHelpers.IsWrapperType(messageDescriptor))
{
return(false);
}
if (JsonConverterHelper.WellKnownTypeNames.ContainsKey(messageDescriptor.FullName))
{
return(false);
}
return(true);
}
public static async Task SendMessage <TResponse>(HttpApiServerCallContext serverCallContext, JsonSerializerOptions serializerOptions, TResponse message) where TResponse : class
{
var response = serverCallContext.HttpContext.Response;
try
{
GrpcServerLog.SendingMessage(serverCallContext.Logger);
object responseBody;
Type responseType;
if (serverCallContext.DescriptorInfo.ResponseBodyDescriptor != null)
{
// TODO: Support recursive response body?
responseBody = serverCallContext.DescriptorInfo.ResponseBodyDescriptor.Accessor.GetValue((IMessage)message);
responseType = JsonConverterHelper.GetFieldType(serverCallContext.DescriptorInfo.ResponseBodyDescriptor);
}
else
{
responseBody = message;
responseType = message.GetType();
}
await JsonRequestHelpers.WriteResponseMessage(response, serverCallContext.RequestEncoding, responseBody, serializerOptions);
GrpcServerLog.SerializedMessage(serverCallContext.Logger, responseType);
GrpcServerLog.MessageSent(serverCallContext.Logger);
}
catch (Exception ex)
{
GrpcServerLog.ErrorSendingMessage(serverCallContext.Logger, ex);
throw;
}
}
internal static JsonSerializerOptions CreateSerializerOptions(JsonSettings?settings, TypeRegistry typeRegistery)
{
var resolvedSettings = settings ?? new JsonSettings {
TypeRegistry = typeRegistery
};
return(JsonConverterHelper.CreateSerializerOptions(resolvedSettings));
}
public override TMessage?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var message = new TMessage();
JsonConverterHelper.PopulateMap(ref reader, options, message, message.Descriptor.Fields[Struct.FieldsFieldNumber]);
return(message);
}
/// <summary>
/// Gets entries [SugarCrm REST method - get_entry_list]
/// </summary>
/// <param name="sessionId">Session identifier</param>
/// <param name="url">REST API Url</param>
/// <param name="moduleName">SugarCrm module name</param>
/// <param name="selectFields">Selected field list</param>
/// <param name="linkedSelectFields">Linked field info.</param>
/// <param name="queryString">Formatted query string.</param>
/// <param name="maxCountResult">Maximum number of entries to return</param>
/// <returns>ReadLinkedEntryListResponse object</returns>
public static async Task <ReadLinkedEntryListResponse> Run(string sessionId, string url, string moduleName, List <string> selectFields, Dictionary <string, List <string> > linkedSelectFields, string queryString, int maxCountResult)
{
var readLinkedEntryListResponse = new ReadLinkedEntryListResponse();
var content = string.Empty;
try
{
dynamic data = new
{
session = sessionId,
module_name = moduleName,
query = queryString,
order_by = string.Empty,
offset = 0,
select_fields = selectFields,
link_name_to_fields_array = LinkedInfoToLinkedFieldsList(linkedSelectFields),
max_results = maxCountResult,
deleted = 0,
favorites = false
};
var client = new RestClient(url);
var request = new RestRequest(string.Empty, Method.POST);
string jsonData = JsonConvert.SerializeObject(data);
request.AddParameter("method", "get_entry_list");
request.AddParameter("input_type", "json");
request.AddParameter("response_type", "json");
request.AddParameter("rest_data", jsonData);
var sugarApiRestResponse = await client.ExecuteEx(request);
var response = sugarApiRestResponse.RestResponse;
if (response.StatusCode == HttpStatusCode.OK)
{
content = response.Content;
readLinkedEntryListResponse = JsonConverterHelper.Deserialize <ReadLinkedEntryListResponse>(content);
readLinkedEntryListResponse.StatusCode = response.StatusCode;
}
else
{
readLinkedEntryListResponse.StatusCode = response.StatusCode;
readLinkedEntryListResponse.Error = ErrorResponse.Format(response);
}
readLinkedEntryListResponse.JsonRawRequest = sugarApiRestResponse.JsonRawRequest;
readLinkedEntryListResponse.JsonRawResponse = sugarApiRestResponse.JsonRawResponse;
}
catch (Exception exception)
{
readLinkedEntryListResponse.StatusCode = HttpStatusCode.InternalServerError;
readLinkedEntryListResponse.Error = ErrorResponse.Format(exception, content);
}
return(readLinkedEntryListResponse);
}
public GrpcJsonTranscodingOptions()
{
_unaryOptions = new Lazy <JsonSerializerOptions>(
() => JsonConverterHelper.CreateSerializerOptions(new JsonContext(JsonSettings, TypeRegistry)),
LazyThreadSafetyMode.ExecutionAndPublication);
_serverStreamingOptions = new Lazy <JsonSerializerOptions>(
() => JsonConverterHelper.CreateSerializerOptions(new JsonContext(JsonSettings, TypeRegistry), isStreamingOptions: true),
LazyThreadSafetyMode.ExecutionAndPublication);
}
public JsonSettings()
{
_unaryOptions = new Lazy <JsonSerializerOptions>(
() => JsonConverterHelper.CreateSerializerOptions(this),
LazyThreadSafetyMode.ExecutionAndPublication);
_serverStreamingOptions = new Lazy <JsonSerializerOptions>(
() => JsonConverterHelper.CreateSerializerOptions(this, isStreamingOptions: true),
LazyThreadSafetyMode.ExecutionAndPublication);
}
public override TMessage?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var message = new TMessage();
var valueDescriptor = message.Descriptor.Fields[JsonConverterHelper.WrapperValueFieldNumber];
var t = JsonConverterHelper.GetFieldType(valueDescriptor);
var value = JsonSerializer.Deserialize(ref reader, t, options);
valueDescriptor.Accessor.SetValue(message, value);
return(message);
}
public void GlobalSetup()
{
_request = new HelloRequest()
{
Name = "Hello world"
};
_serializerOptions = JsonConverterHelper.CreateSerializerOptions(new JsonSettings {
WriteIndented = false
});
_jsonFormatter = new JsonFormatter(new JsonFormatter.Settings(formatDefaultValues: false));
}
public void GlobalSetup()
{
_requestJson = (new HelloRequest()
{
Name = "Hello world"
}).ToString();
_serializerOptions = JsonConverterHelper.CreateSerializerOptions(new JsonContext(new GrpcJsonSettings {
WriteIndented = false
}, TypeRegistry.Empty));
_jsonFormatter = new JsonParser(new JsonParser.Settings(recursionLimit: 100));
}
/// <summary>
/// Gets entry [SugarCrm REST method - get_entry]
/// </summary>
/// <param name="sessionId">Session identifier</param>
/// <param name="url">REST API Url</param>
/// <param name="moduleName">SugarCrm module name</param>
/// <param name="identifier">The entity identifier</param>
/// <param name="selectFields">Selected field list</param>
/// <returns>ReadEntryResponse object</returns>
public static async Task <ReadEntryResponse> Run(string sessionId, string url, string moduleName, string identifier, List <string> selectFields)
{
var readEntryResponse = new ReadEntryResponse();
var content = string.Empty;
try
{
dynamic data = new
{
session = sessionId,
module_name = moduleName,
id = identifier,
select_fields = selectFields,
link_name_to_fields_array = string.Empty,
track_view = false
};
var client = new RestClient(url);
var request = new RestRequest(string.Empty, Method.POST);
string jsonData = JsonConvert.SerializeObject(data);
request.AddParameter("method", "get_entry");
request.AddParameter("input_type", "json");
request.AddParameter("response_type", "json");
request.AddParameter("rest_data", jsonData);
var sugarApiRestResponse = await client.ExecuteEx(request);
var response = sugarApiRestResponse.RestResponse;
if (response.StatusCode == HttpStatusCode.OK)
{
content = response.Content;
readEntryResponse = JsonConverterHelper.Deserialize <ReadEntryResponse>(content);
readEntryResponse.StatusCode = response.StatusCode;
}
else
{
readEntryResponse.StatusCode = response.StatusCode;
readEntryResponse.Error = ErrorResponse.Format(response);
}
readEntryResponse.JsonRawRequest = sugarApiRestResponse.JsonRawRequest;
readEntryResponse.JsonRawResponse = sugarApiRestResponse.JsonRawResponse;
}
catch (Exception exception)
{
readEntryResponse.StatusCode = HttpStatusCode.InternalServerError;
readEntryResponse.Error = ErrorResponse.Format(exception, content);
}
return(readEntryResponse);
}
/// <summary>
/// Insert entity.
/// </summary>
/// <param name="client">SugarRestClient object.</param>
/// <param name="request">The request object.</param>
/// <param name="modelInfo">The entity model info.</param>
/// <returns>SugarRestResponse object.</returns>
public static SugarRestResponse ExecuteInsert(this SugarRestClient client, SugarRestRequest request, ModelInfo modelInfo)
{
var sugarRestResponse = new SugarRestResponse();
var loginResponse = new LoginResponse();
try
{
var loginRequest = new LoginRequest
{
Url = request.Url,
Username = request.Username,
Password = request.Password
};
loginResponse = Authentication.Login(loginRequest);
JObject jobject = JsonConverterHelper.Serialize(request.Parameter, modelInfo.Type);
var selectFields = modelInfo.GetJsonPropertyNames(request.Options.SelectFields);
var insertEntryResponse = InsertEntry.Run(loginResponse.SessionId, loginRequest.Url, request.ModuleName, jobject, selectFields);
if (insertEntryResponse != null)
{
sugarRestResponse.JsonRawRequest = insertEntryResponse.JsonRawRequest;
sugarRestResponse.JsonRawResponse = insertEntryResponse.JsonRawResponse;
if (!string.IsNullOrEmpty(insertEntryResponse.Id))
{
sugarRestResponse.Data = insertEntryResponse.Id;
sugarRestResponse.JData = (insertEntryResponse.Id == null) ? null : JToken.FromObject(insertEntryResponse.Id).ToString();
sugarRestResponse.StatusCode = insertEntryResponse.StatusCode;
}
else
{
sugarRestResponse.Error = insertEntryResponse.Error;
sugarRestResponse.StatusCode = insertEntryResponse.StatusCode;
}
}
return(sugarRestResponse);
}
catch (Exception exception)
{
sugarRestResponse.StatusCode = HttpStatusCode.InternalServerError;
sugarRestResponse.Error = ErrorResponse.Format(exception, string.Empty);
}
finally
{
Authentication.Logout(request.Url, loginResponse.SessionId);
}
return(sugarRestResponse);
}
/// <summary>
/// Update entities.
/// </summary>
/// <param name="client">SugarRestClient object.</param>
/// <param name="request">The request object.</param>
/// <param name="modelInfo">The entity model info.</param>
/// <returns>SugarRestResponse object.</returns>
public static SugarRestResponse ExecuteUpdates(this SugarRestClient client, SugarRestRequest request, ModelInfo modelInfo)
{
var sugarRestResponse = new SugarRestResponse();
var loginResponse = new LoginResponse();
try
{
var loginRequest = new LoginRequest
{
Url = request.Url,
Username = request.Username,
Password = request.Password
};
loginResponse = Authentication.Login(loginRequest);
JArray objectList = JsonConverterHelper.SerializeList(request.Parameter, modelInfo.Type);
var selectFields = modelInfo.GetJsonPropertyNames(request.Options.SelectFields);
var updateEntriesResponse = UpdateEntries.Run(loginResponse.SessionId, loginRequest.Url, request.ModuleName, objectList, selectFields);
if (updateEntriesResponse != null)
{
sugarRestResponse.JsonRawRequest = updateEntriesResponse.JsonRawRequest;
sugarRestResponse.JsonRawResponse = updateEntriesResponse.JsonRawResponse;
if ((updateEntriesResponse.Ids != null) && (updateEntriesResponse.Ids.Count > 0))
{
sugarRestResponse.Data = updateEntriesResponse.Ids;
sugarRestResponse.JData = (updateEntriesResponse.Ids == null) ? null : JArray.FromObject(updateEntriesResponse.Ids).ToString();
sugarRestResponse.StatusCode = updateEntriesResponse.StatusCode;
}
else
{
sugarRestResponse.Error = updateEntriesResponse.Error;
sugarRestResponse.StatusCode = updateEntriesResponse.StatusCode;
}
}
return(sugarRestResponse);
}
catch (Exception exception)
{
sugarRestResponse.StatusCode = HttpStatusCode.InternalServerError;
sugarRestResponse.Error = ErrorResponse.Format(exception, string.Empty);
}
finally
{
Authentication.Logout(request.Url, loginResponse.SessionId);
}
return(sugarRestResponse);
}
public override TMessage Read(
ref Utf8JsonReader reader,
Type typeToConvert,
JsonSerializerOptions options)
{
var message = new TMessage();
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new JsonException($"Unexpected JSON token: {reader.TokenType}");
}
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonTokenType.EndObject:
return(message);
case JsonTokenType.PropertyName:
if (_jsonFieldMap.TryGetValue(reader.GetString() !, out var fieldDescriptor))
{
if (fieldDescriptor.ContainingOneof != null)
{
if (fieldDescriptor.ContainingOneof.Accessor.GetCaseFieldDescriptor(message) != null)
{
throw new InvalidOperationException($"Multiple values specified for oneof {fieldDescriptor.ContainingOneof.Name}.");
}
}
if (fieldDescriptor.IsMap)
{
JsonConverterHelper.PopulateMap(ref reader, options, message, fieldDescriptor);
}
else if (fieldDescriptor.IsRepeated)
{
JsonConverterHelper.PopulateList(ref reader, options, message, fieldDescriptor);
}
else
{
var fieldType = JsonConverterHelper.GetFieldType(fieldDescriptor);
var propertyValue = JsonSerializer.Deserialize(ref reader, fieldType, options);
fieldDescriptor.Accessor.SetValue(message, propertyValue);
}
}
else
{
reader.Skip();
}
break;
/// <summary>
/// Updates entry [SugarCrm REST method - set_entry]
/// </summary>
/// <param name="sessionId">Session identifier</param>
/// <param name="url">REST API Url</param>
/// <param name="moduleName">SugarCrm module name</param>
/// <param name="entity">The entity object to update</param>
/// <param name="selectFields">Selected field list</param>
/// <returns>ReadEntryResponse object</returns>
public static async Task <UpdateEntryResponse> Run(string sessionId, string url, string moduleName, JObject entity, List <string> selectFields)
{
var updateEntryResponse = new UpdateEntryResponse();
var content = string.Empty;
try
{
dynamic data = new
{
session = sessionId,
module_name = moduleName,
name_value_list = EntityToNameValueList(entity, selectFields)
};
var client = new RestClient(url);
var request = new RestRequest(string.Empty, Method.POST);
string jsonData = JsonConvert.SerializeObject(data);
request.AddParameter("method", "set_entry");
request.AddParameter("input_type", "json");
request.AddParameter("response_type", "json");
request.AddParameter("rest_data", jsonData);
var sugarApiRestResponse = await client.ExecuteEx(request);
var response = sugarApiRestResponse.RestResponse;
if (response.StatusCode == HttpStatusCode.OK)
{
content = response.Content;
updateEntryResponse = JsonConverterHelper.Deserialize <UpdateEntryResponse>(content);
updateEntryResponse.StatusCode = response.StatusCode;
}
else
{
updateEntryResponse.StatusCode = response.StatusCode;
updateEntryResponse.Error = ErrorResponse.Format(response);
}
updateEntryResponse.JsonRawRequest = sugarApiRestResponse.JsonRawRequest;
updateEntryResponse.JsonRawResponse = sugarApiRestResponse.JsonRawResponse;
}
catch (Exception exception)
{
updateEntryResponse.StatusCode = HttpStatusCode.InternalServerError;
updateEntryResponse.Error = ErrorResponse.Format(exception, content);
}
return(updateEntryResponse);
}
/// <summary>
/// Deletes entry [SugarCrm REST method -set_entry (sets deleted to 1]
/// </summary>
/// <param name="sessionId">Session identifier</param>
/// <param name="url">REST API Url</param>
/// <param name="moduleName">SugarCrm module name</param>
/// <param name="id">The entity identifier</param>
/// <returns>DeleteEntryResponse object</returns>
public static DeleteEntryResponse Run(string sessionId, string url, string moduleName, string id)
{
var deleteEntryResponse = new DeleteEntryResponse();
var content = string.Empty;
try
{
dynamic data = new
{
session = sessionId,
module_name = moduleName,
name_value_list = DeleteDataToNameValueList(id)
};
var client = new RestClient(url);
var request = new RestRequest(string.Empty, Method.POST);
string jsonData = JsonConvert.SerializeObject(data);
request.AddParameter("method", "set_entry");
request.AddParameter("input_type", "json");
request.AddParameter("response_type", "json");
request.AddParameter("rest_data", jsonData);
var sugarApiRestResponse = client.ExecuteEx(request);
var response = sugarApiRestResponse.RestResponse;
if (response.StatusCode == HttpStatusCode.OK)
{
content = response.Content;
deleteEntryResponse = JsonConverterHelper.Deserialize <DeleteEntryResponse>(content);
deleteEntryResponse.StatusCode = response.StatusCode;
}
else
{
deleteEntryResponse.StatusCode = response.StatusCode;
deleteEntryResponse.Error = ErrorResponse.Format(response);
}
deleteEntryResponse.JsonRawRequest = sugarApiRestResponse.JsonRawRequest;
deleteEntryResponse.JsonRawResponse = sugarApiRestResponse.JsonRawResponse;
}
catch (Exception exception)
{
deleteEntryResponse.StatusCode = HttpStatusCode.InternalServerError;
deleteEntryResponse.Error = ErrorResponse.Format(exception, content);
}
return(deleteEntryResponse);
}
public override JsonConverter CreateConverter(
Type typeToConvert, JsonSerializerOptions options)
{
var descriptor = JsonConverterHelper.GetMessageDescriptor(typeToConvert) !;
var converterType = JsonConverterHelper.WellKnownTypeNames[descriptor.FullName];
var converter = (JsonConverter)Activator.CreateInstance(
converterType.MakeGenericType(new Type[] { typeToConvert }),
BindingFlags.Instance | BindingFlags.Public,
binder: null,
args: new object[] { _context },
culture: null) !;
return(converter);
}
public override bool CanConvert(Type typeToConvert)
{
if (!typeof(IMessage).IsAssignableFrom(typeToConvert))
{
return(false);
}
var descriptor = JsonConverterHelper.GetMessageDescriptor(typeToConvert);
if (descriptor == null)
{
return(false);
}
return(ServiceDescriptorHelpers.IsWrapperType(descriptor));
}
public override bool CanConvert(Type typeToConvert)
{
if (!typeof(IMessage).IsAssignableFrom(typeToConvert))
{
return(false);
}
var descriptor = JsonConverterHelper.GetMessageDescriptor(typeToConvert);
if (descriptor == null)
{
return(false);
}
return(JsonConverterHelper.WellKnownTypeNames.ContainsKey(descriptor.FullName));
}
private async void DoWork(object state)
{
_count++;
Random Rnd = new Random();
double temp = Rnd.Next(100, 700) / 10.0;
TemperatureSensor p = new TemperatureSensor()
{
megnumber = _count.ToString()
};
if (temp > 40)
{
p.alerttype = "overheating";
}
else
{
p.alerttype = "normal";
}
p.timestamp = DateTime.Now.ToString();
p.temperature = temp;
string json = new JsonConverterHelper().Object2Json(p, typeof(TemperatureSensor));
Console.WriteLine("Message #" + _count + " " + json);
var messageBytes = System.Text.Encoding.UTF8.GetBytes(json);
if (_webSocket != null)
{
await _webSocket.SendAsync(new ArraySegment <byte>(messageBytes), WebSocketMessageType.Binary, true, _cancellation);
}
this.Dispatcher.Invoke(() =>
{
outmegs.Text += new StringBuilder().AppendLine("Message sent " + json).ToString();
sv.ScrollToVerticalOffset(outmegs.ActualHeight);
});
Console.WriteLine("Message sent " + json);
}
internal static void WriteMessageFields(Utf8JsonWriter writer, IMessage message, GrpcJsonSettings settings, JsonSerializerOptions options)
{
var fields = message.Descriptor.Fields;
foreach (var field in fields.InFieldNumberOrder())
{
var accessor = field.Accessor;
var value = accessor.GetValue(message);
if (!JsonConverterHelper.ShouldFormatFieldValue(message, field, value, !settings.IgnoreDefaultValues))
{
continue;
}
writer.WritePropertyName(accessor.Descriptor.JsonName);
JsonSerializer.Serialize(writer, value, value.GetType(), options);
}
}
private static JsonSerializerSettings ConfigureSettings()
{
var settings = new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
};
settings.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy()));
foreach (var jsonConverter in JsonConverterHelper.GetSpecificClassConverters())
{
settings.Converters.Add(jsonConverter);
}
return(settings);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
#region 自定义Session 这里使用了长连接，接入了其他服务，改成可以直接独立运行的版本。
//ShellSession.InitSession<RedisSession>();
//services.AddDiySession(c =>
//{
// c.GetDiySession<RedisSession>();
//});
//services.AddObject(TcpFrame.CreateServer(AppSettings.Get("ServerIp"), 888));
#endregion
#region 自定义Session 独立运行版本，0.0.1
ShellSession.InitSession <CacheSession>();
services.AddDiySession(c =>
{
c.GetDiySession <CacheSession>();
});
CacheSession.StartKeep(1); // 每秒一次自检测
#endregion
services.AddResponseCompression();
services.AddAshx(o =>
{
//o.IsAsync = true;
o.JsonOptions = new()// System.Text.Json.JsonSerializerOptions(System.Text.Json.JsonSerializerDefaults.Web)
{
//IgnoreReadOnlyFields = true,
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All),
};
//o.JsonOptions.Converters.Add(JsonConverterHelper.GetDateConverter());
o.JsonOptions.Converters.Add(JsonConverterHelper.GetDBNullConverter());
});//注册api。
//.AddHttpContext();//注册静态方式的HttpContext对象获取。
services.AddObject(new UpLoad());//上传有关配置注册
}
private static EnumDescriptor?ResolveEnumDescriptor(Type typeToConvert)
{
var containingType = typeToConvert?.DeclaringType?.DeclaringType;
if (containingType != null)
{
var messageDescriptor = JsonConverterHelper.GetMessageDescriptor(containingType);
if (messageDescriptor != null)
{
for (var i = 0; i < messageDescriptor.EnumTypes.Count; i++)
{
if (messageDescriptor.EnumTypes[i].ClrType == typeToConvert)
{
return(messageDescriptor.EnumTypes[i]);
}
}
}
}
return(null);
}
private async static void DoWork(object state)
{
_count++;
Random Rnd = new Random();
double temp = Rnd.Next(100, 700) / 10.0;
TemperatureSensor p = new TemperatureSensor();
if (temp > 50)
{
p.alerttype = "overheating";
}
else
{
p.alerttype = "normal";
}
p.timestamp = DateTime.Now.ToString();
p.temperature = temp;
string json = new JsonConverterHelper().Object2Json(p, typeof(TemperatureSensor));
Console.WriteLine("Message #" + _count + " " + json);
var messageBytes = System.Text.Encoding.UTF8.GetBytes(json);
//Encoding.UTF8.GetBytes(messageBody)
Message pipeMessage = new Message(messageBytes);
// if (temp > 50)
// pipeMessage.Properties.Add("MessageType", "Alert");
await _moduleClient.SendEventAsync("TemperatureModuleOutput", pipeMessage);
Console.WriteLine("Message sent " + json);
}
private JsonPropertyInfo CreatePropertyInfo(JsonTypeInfo typeInfo, string name, FieldDescriptor field, bool isSerializable)
{
var propertyInfo = typeInfo.CreateJsonPropertyInfo(
JsonConverterHelper.GetFieldType(field),
name);
// Properties that don't have this flag set are only used to deserialize incoming JSON.
if (isSerializable)
{
propertyInfo.ShouldSerialize = (o, v) =>
{
return(JsonConverterHelper.ShouldFormatFieldValue((IMessage)o, field, v, !_context.Settings.IgnoreDefaultValues));
};
propertyInfo.Get = (o) =>
{
return(field.Accessor.GetValue((IMessage)o));
};
}
propertyInfo.Set = GetSetMethod(field);
return(propertyInfo);
}
internal static JsonSerializerOptions CreateSerializerOptions(GrpcJsonSettings?settings, TypeRegistry?typeRegistery)
{
var context = new JsonContext(settings ?? new GrpcJsonSettings(), typeRegistery ?? TypeRegistry.Empty);
return(JsonConverterHelper.CreateSerializerOptions(context));
}
/// <summary>
/// Serializes an object into a JSON string adding Properties.
/// </summary>
/// <param name="writer">The JSON writer.</param>
/// <param name="value">The value to serialize.</param>
/// <param name="serializer">The JSON serializer.</param>
public override void WriteJson(JsonWriter writer,
object value, JsonSerializer serializer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
// If generic resource - serialize as-is
if (value.GetType().GetTypeInfo().DeclaredProperties.Any(p => p.Name == "Properties" && p.PropertyType == typeof(object)))
{
GetSerializerWithoutCurrentConverter(serializer).Serialize(writer, value);
return;
}
// Add discriminator field
writer.WriteStartObject();
// If there is polymorphism - add polymorphic property
var polymorphicSerializer = serializer.Converters
.FirstOrDefault(c =>
c.GetType().GetTypeInfo().IsGenericType&&
c.GetType().GetGenericTypeDefinition() == typeof(PolymorphicSerializeJsonConverter <>) &&
c.CanConvert(value.GetType())) as PolymorphicJsonConverter;
if (polymorphicSerializer != null)
{
writer.WritePropertyName(polymorphicSerializer.Discriminator);
string typeName = value.GetType().Name;
if (value.GetType().GetTypeInfo().GetCustomAttributes <JsonObjectAttribute>().Any())
{
typeName = value.GetType().GetTypeInfo().GetCustomAttribute <JsonObjectAttribute>().Id;
}
writer.WriteValue(typeName);
}
// Go over each property that is in resource and write to stream
JsonConverterHelper.SerializeProperties(writer, value, serializer,
p => !p.PropertyName.StartsWith("properties.", StringComparison.OrdinalIgnoreCase));
// If there is a need to add properties element - add it
var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());
if (contract.Properties.Any(p =>
p.PropertyName.StartsWith("properties.", StringComparison.OrdinalIgnoreCase) &&
(p.ValueProvider.GetValue(value) != null ||
serializer.NullValueHandling == NullValueHandling.Include)))
{
writer.WritePropertyName(PropertiesNode);
writer.WriteStartObject();
JsonConverterHelper.SerializeProperties(writer, value, serializer,
p => p.PropertyName.StartsWith("properties.", StringComparison.OrdinalIgnoreCase));
writer.WriteEndObject();
}
writer.WriteEndObject();
}
public static async ValueTask <TRequest> ReadMessage <TRequest>(JsonTranscodingServerCallContext serverCallContext, JsonSerializerOptions serializerOptions) where TRequest : class
{
try
{
GrpcServerLog.ReadingMessage(serverCallContext.Logger);
IMessage requestMessage;
if (serverCallContext.DescriptorInfo.BodyDescriptor != null)
{
Type type;
object bodyContent;
if (serverCallContext.DescriptorInfo.BodyDescriptor.FullName == HttpBody.Descriptor.FullName)
{
type = typeof(HttpBody);
bodyContent = await ReadHttpBodyAsync(serverCallContext);
}
else
{
if (!serverCallContext.IsJsonRequestContent)
{
GrpcServerLog.UnsupportedRequestContentType(serverCallContext.Logger, serverCallContext.HttpContext.Request.ContentType);
throw new InvalidOperationException($"Unable to read the request as JSON because the request content type '{serverCallContext.HttpContext.Request.ContentType}' is not a known JSON content type.");
}
var(stream, usesTranscodingStream) = GetStream(serverCallContext.HttpContext.Request.Body, serverCallContext.RequestEncoding);
try
{
if (serverCallContext.DescriptorInfo.BodyDescriptorRepeated)
{
requestMessage = (IMessage)Activator.CreateInstance <TRequest>();
// TODO: JsonSerializer currently doesn't support deserializing values onto an existing object or collection.
// Either update this to use new functionality in JsonSerializer or improve work-around perf.
type = JsonConverterHelper.GetFieldType(serverCallContext.DescriptorInfo.BodyFieldDescriptors.Last());
type = typeof(List <>).MakeGenericType(type);
GrpcServerLog.DeserializingMessage(serverCallContext.Logger, type);
bodyContent = (await JsonSerializer.DeserializeAsync(stream, type, serializerOptions)) !;
if (bodyContent == null)
{
throw new InvalidOperationException($"Unable to deserialize null to {type.Name}.");
}
}
else
{
type = serverCallContext.DescriptorInfo.BodyDescriptor.ClrType;
GrpcServerLog.DeserializingMessage(serverCallContext.Logger, type);
bodyContent = (IMessage)(await JsonSerializer.DeserializeAsync(stream, serverCallContext.DescriptorInfo.BodyDescriptor.ClrType, serializerOptions)) !;
}
}
finally
{
if (usesTranscodingStream)
{
await stream.DisposeAsync();
}
}
}
if (serverCallContext.DescriptorInfo.BodyFieldDescriptors != null)
{
requestMessage = (IMessage)Activator.CreateInstance <TRequest>();
ServiceDescriptorHelpers.RecursiveSetValue(requestMessage, serverCallContext.DescriptorInfo.BodyFieldDescriptors, bodyContent); // TODO - check nullability
}
else
{
if (bodyContent == null)
{
throw new InvalidOperationException($"Unable to deserialize null to {type.Name}.");
}
requestMessage = (IMessage)bodyContent;
}
}
else
{
requestMessage = (IMessage)Activator.CreateInstance <TRequest>();
}
foreach (var parameterDescriptor in serverCallContext.DescriptorInfo.RouteParameterDescriptors)
{
var routeValue = serverCallContext.HttpContext.Request.RouteValues[parameterDescriptor.Key];
if (routeValue != null)
{
ServiceDescriptorHelpers.RecursiveSetValue(requestMessage, parameterDescriptor.Value, routeValue);
}
}
foreach (var item in serverCallContext.HttpContext.Request.Query)
{
if (CanBindQueryStringVariable(serverCallContext, item.Key))
{
var pathDescriptors = GetPathDescriptors(serverCallContext, requestMessage, item.Key);
if (pathDescriptors != null)
{
var value = item.Value.Count == 1 ? (object?)item.Value[0] : item.Value;
ServiceDescriptorHelpers.RecursiveSetValue(requestMessage, pathDescriptors, value);
}
}
}
GrpcServerLog.ReceivedMessage(serverCallContext.Logger);
return((TRequest)requestMessage);
}
catch (JsonException ex)
{
GrpcServerLog.ErrorReadingMessage(serverCallContext.Logger, ex);
throw new RpcException(new Status(StatusCode.InvalidArgument, "Request JSON payload is not correctly formatted.", ex));
}
catch (Exception ex)
{
GrpcServerLog.ErrorReadingMessage(serverCallContext.Logger, ex);
throw new RpcException(new Status(StatusCode.InvalidArgument, ex.Message, ex));
}
}
