public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) {
if (!config.IsValid)
return new SubmissionResponse(500, message: "Invalid client configuration settings.");
string data = serializer.Serialize(description);
string url = String.Format("{0}/events/by-ref/{1}/user-description", GetServiceEndPoint(config), referenceId);
HttpResponseMessage response;
try {
HttpContent content = new StringContent(data, Encoding.UTF8, "application/json");
// don't compress data smaller than 4kb
if (data.Length > 1024 * 4)
content = new GzipContent(content);
_client.Value.AddAuthorizationHeader(config.ApiKey);
response = _client.Value.PostAsync(url, content).ConfigureAwait(false).GetAwaiter().GetResult();
} catch (Exception ex) {
return new SubmissionResponse(500, message: ex.Message);
}
int settingsVersion;
if (Int32.TryParse(GetSettingsVersionHeader(response.Headers), out settingsVersion))
SettingsManager.CheckVersion(settingsVersion, config);
return new SubmissionResponse((int)response.StatusCode, GetResponseMessage(response));
}
static void BuildAssignments(JavaScriptObject dictionary, StringBuilder builder, IJsonSerializer jsonSerializer)
{
foreach (var pair in dictionary)
{
var value = jsonSerializer.Serialize(pair.Value);
builder.AppendFormat("d.{0}={1};", pair.Key, value).AppendLine();
}
}
public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) {
foreach (Event e in events) {
string data = serializer.Serialize(e);
string referenceId = !string.IsNullOrWhiteSpace(e.ReferenceId) ? e.ReferenceId : Guid.NewGuid().ToString("D");
_eventContainer[referenceId] = data;
}
return new SubmissionResponse(200);
}
public static PublishCommandJob Create(
ICommand command,
ICommandDefinitionService commandDefinitionService,
IJsonSerializer jsonSerializer)
{
var data = jsonSerializer.Serialize(command);
var commandDefinition = commandDefinitionService.GetDefinition(command.GetType());
return new PublishCommandJob(
data,
commandDefinition.Name,
commandDefinition.Version);
}
private TopicMessage CreateTopicMessage(IDomainException exception)
{
var topic = _exceptionTopicProvider.GetTopic(exception);
var serializableInfo = new Dictionary <string, string>();
exception.SerializeTo(serializableInfo);
var data = _jsonSerializer.Serialize(new DomainExceptionMessage
{
UniqueId = exception.Id,
Timestamp = exception.Timestamp,
Items = exception.Items,
SerializableInfo = serializableInfo
});
return(new TopicMessage(topic, (int)MessageTypeCode.ExceptionMessage, Encoding.UTF8.GetBytes(data), "text/json", _typeNameProvider.GetTypeName(exception.GetType())));
}
public HttpResponse Convert(JsonRpcResponse response)
{
if (response == null)
{
return(HttpResponse.ServerError("Null Command Result"));
}
var body = serializer.Serialize(response, true);
if (!string.IsNullOrWhiteSpace(response.error))
{
return(HttpResponse.ServerError(body));
}
return(HttpResponse.Success(body));
}
public EventData ToEventData(Envelope <IEvent> envelope, Guid commitId, bool migrate = true)
{
var eventPayload = envelope.Payload;
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var payloadType = typeNameRegistry.GetName(eventPayload.GetType());
var payloadJson = serializer.Serialize(envelope.Payload);
envelope.SetCommitId(commitId);
return(new EventData(payloadType, envelope.Headers, payloadJson));
}
public Task PublishAsync <TMessage>(TMessage message, string recipient)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
var messageType = message.GetType().Name;
var payload = _jsonSerializer.Serialize(message);
var outboxMessage = new OutgoingActorMessage(_systemDateTimeProvider.Now(), messageType, payload, recipient);
_unitOfWorkCallback.RegisterNew(outboxMessage, this);
return(Task.CompletedTask);
}
public void CanSetMaxDepth()
{
var data = new SampleModel {
Message = "Level 1",
Nested = new SampleModel {
Message = "Level 2",
Nested = new SampleModel {
Message = "Level 3"
}
}
};
IJsonSerializer serializer = GetSerializer();
string json = serializer.Serialize(data, maxDepth: 2);
Assert.Equal(@"{""message"":""Level 1"",""nested"":{""message"":""Level 2""}}", json);
}
public override void SetUp()
{
base.SetUp();
serializer = new JsonSerializerAdapter();
config = BuildRoutine.ServiceClientConfig().FromBasic()
.ServiceUrlBase.Set(URL_BASE)
;
mock = new Mock <IRestClient>();
testing = new RestClientObjectService(config, mock.Object, serializer);
stubber = new TRestClientStubber();
invoker = new TDoInvoker();
mock.Setup(rc => rc.Get($"{URL_BASE}/ApplicationModel", It.IsAny <RestRequest>()))
.Returns(() => new RestResponse(serializer.Serialize(GetApplicationModel())));
}
public bool Publish <T>(
T info,
string exchangeName,
string queueName,
string routkey,
bool persistent = false,
bool durableQueue = true,
bool autoDelete = false,
bool exclusive = false,
ExchangeType exchangeType = ExchangeType.Default)
{
try
{
var conn = StartConnect();
var channel = conn.CreateModel();
if (exchangeType != ExchangeType.Default)
{
string strExchangeType = ExchangeTypeDataDict.ExchangeTypeDict[exchangeType];
channel.ExchangeDeclare(exchangeName, strExchangeType);
}
channel.QueueDeclare(queue: queueName,
durable: durableQueue,
exclusive: exclusive,
autoDelete: autoDelete,
arguments: null);
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
var data = _jsonSerializer.Serialize(info);
var body = Encoding.UTF8.GetBytes(data);
channel.BasicPublish(exchange: exchangeName,
routingKey: routkey,
basicProperties: properties,
body: body);
return(true);
}
catch (Exception ex)
{
_logger.Error($"发布消息失败，异常是：{ex.Message},详细信息是：{ex.StackTrace}");
return(false);
}
}
public void Add_Send_Json_Message_To_Queue()
{
var profile = new Profile();
string expectedJson = "{test: 233}";
var expectedId = Guid.NewGuid().ToString();
_mockResponse = expectedId;
_serializer.Serialize(profile).Returns(expectedJson);
var actualId = _adapter.Add(profile);
_serializer.Received().Serialize(profile);
Assert.AreEqual(_requests.First().Headers["Content-Type"], _applicationJsonHeader);
Assert.AreEqual(_requests.First().Headers["Accept"], _applicationJsonHeader);
Assert.That(_requests.First().Url.LocalPath, Is.EqualTo("/api/Queue/Add"));
Assert.That(_requests.First().HttpMethod, Is.EqualTo("POST"));
Assert.AreEqual(actualId, expectedId);
}
/// <summary>
/// 设置远程异常
/// </summary>
/// <param name="serializer">序列化工具</param>
/// <param name="exceptionContext">上下文</param>
/// <returns></returns>
public static bool SetRemoteException(IJsonSerializer serializer, ExceptionContext exceptionContext)
{
try
{
var packet = exceptionContext.Packet;
packet.state = false;
packet.body = exceptionContext.Exception.Message;
var packetJson = serializer.Serialize(packet);
exceptionContext.Session.SendText(packetJson);
return(true);
}
catch (Exception)
{
return(false);
}
}
// TODO: Ability to deserialize objects without underscores
//[Fact]
public void CanDeserializeDataWithoutUnderscores()
{
const string json = @"{""BlahId"":""Hello""}";
const string jsonWithUnderScore = @"{""blah_id"":""Hello""}";
IJsonSerializer serializer = GetSerializer();
var value = serializer.Deserialize <Blah>(json);
Assert.Equal("Hello", value.BlahId);
value = serializer.Deserialize <Blah>(jsonWithUnderScore);
Assert.Equal("Hello", value.BlahId);
string serialized = serializer.Serialize(value);
Assert.Equal(jsonWithUnderScore, serialized);
}
public static HttpContent PrepareFor(object model, IJsonSerializer serializer, RestRequestOptions options)
{
var bytes = serializer.Serialize(model);
if (Library.Debug.DumpJson)
{
Library.Debug.DumpWriter.WriteLine(Encoding.UTF8.GetString(bytes.Span));
}
var content = new ReadOnlyMemoryContent(bytes);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json")
{
CharSet = Encoding.UTF8.WebName
};
return(content);
}
public async Task SaveInstallLogAsync(InstallLog installLog)
{
try
{
if (_httpClient == null)
{
_httpClient = new HttpClient();
}
var content = new StringContent(_jsonSerializer.Serialize(installLog), Encoding.UTF8, "application/json");
await _httpClient.PostAsync(RestApiInstallUrl, content);
}
// this occurs if the server for Our is down or cannot be reached
catch (HttpRequestException)
{ }
}
public async Task <ApiResult> Insert(ManageFieldMetadataRequest request, CancellationToken cancellationToken)
{
var items = request.Items ?? throw new ArgumentNullException(nameof(request.Items));
var dbItems = new List <DbFieldMetadata>();
foreach (var item in items)
{
var properties = item.GetProperties();
var extra = properties != null?_jsonSerializer.Serialize(properties) : null;
dbItems.Add(new DbFieldMetadata
{
Uid = Guid.NewGuid(),
EntityTypeCode = request.EntityTypeCode,
EntityUid = request.EntityUid,
Type = item.Type,
Key = item.Key,
Name = item.Name,
Description = item.Description,
Placeholder = item.Placeholder,
Icon = item.Icon,
IsActive = true,
IsSystem = item.System,
IsReadonly = item.Readonly,
IsRequired = item.Required,
DisplayOrder = item.DisplayOrder,
CreatedAtUtc = _dateTimeProvider.GetUtcNow(),
Props = extra
});
}
using (var db = _dbContextFactory.Create())
{
var rowsCopied = await db.GetTable <DbFieldMetadata>()
.BulkCopyAsync(dbItems, cancellationToken);
return(new ApiResult
{
AffectedRows = rowsCopied.RowsCopied,
Uid = dbItems.Count == 1 ? dbItems[0].Uid : null
});
}
}
private Task HandleExceptionAsync(HttpContext context, Exception exception)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
string message = "Unexpected error occurred!";
if (exception is BusinessException)
{
message = exception.Message;
}
return(context.Response.WriteAsync(jsonSerializer.Serialize(new ResponseBase()
{
IsSuccess = false,
Message = message
}, CaseStyleType.CamelCase)));
}
private void ComputeTokens(IEnumerable <IEnrichedAssetEntity> assets)
{
var url = urlGenerator.Root();
foreach (var asset in assets)
{
var token = new
{
a = asset.AppId.Name,
i = asset.Id.ToString(),
u = url
};
var json = jsonSerializer.Serialize(token);
asset.EditToken = Convert.ToBase64String(Encoding.UTF8.GetBytes(json));
}
}
private void SaveCommentFormUser(LastCommentFormUserInfo user)
{
if (user == null)
{
return;
}
var jsonString = _jsonSerializer.Serialize(user);
Response.Cookies.Append(
"lastCommentUser",
jsonString,
new Microsoft.AspNetCore.Http.CookieOptions()
{
Expires = DateTime.Now.AddDays(7),
HttpOnly = true
});
}
public static void DebugWriteJson(this IDocumentStore documentStore, object o)
{
if (_serializer == null)
{
_serializer = documentStore.Conventions.Serialization.CreateSerializer();
}
var sb = new StringBuilder();
using (var stringWriter = new StringWriter(sb))
using (var jsonWriter = new JsonTextWriter(stringWriter))
using (var adaptor = new JsonWriterAdaptor(jsonWriter))
{
_serializer.Serialize(adaptor, o);
}
Debug.WriteLine(sb);
}
private void SaveQueueSetting()
{
if (_chunkManager.IsMemoryMode)
{
return;
}
if (!Directory.Exists(_chunkManager.ChunkPath))
{
Directory.CreateDirectory(_chunkManager.ChunkPath);
}
using (var stream = new FileStream(_queueSettingFile, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
using (var writer = new StreamWriter(stream))
{
writer.Write(_jsonSerializer.Serialize(_setting));
}
}
}
private Task WriteResponse <T>(T response, int?statusCode = null)
{
var realContentType = Request.GetAcceptHeaders().Contains(xmlContentType)
? xmlContentType
: jsonContentType;
var bytes = realContentType == xmlContentType
? xmlSerializer.Serialize(response)
: jsonSerializer.Serialize(response);
Response.Headers.Add("Content-Type", realContentType);
if (statusCode.HasValue)
{
Response.StatusCode = statusCode.Value;
}
return(Response.Body.WriteAsync(bytes, 0, bytes.Length));
}
public SubmissionResponse Submit(IEnumerable <Event> events, ExceptionlessConfiguration configuration, IJsonSerializer serializer)
{
HttpWebRequest client = WebRequest.CreateHttp(String.Concat(configuration.GetServiceEndPoint(), "events"));
client.SetUserAgent(configuration.UserAgent);
client.AddAuthorizationHeader(configuration);
var data = serializer.Serialize(events);
var response = client.PostJsonAsync(data).Result;
int settingsVersion;
if (!Int32.TryParse(response.Headers[ExceptionlessHeaders.ConfigurationVersion], out settingsVersion))
{
settingsVersion = -1;
}
return(new SubmissionResponse((int)response.StatusCode, settingsVersion, response.StatusCode == HttpStatusCode.Accepted ? null : response.GetResponseText()));
}
public async Task Invoke(HttpContext context, IJsonSerializer jsonSerializer, ILogger <ErrorHandlingMiddleware> logger)
{
try
{
await next(context);
}
catch (Exception e)
{
logger.LogError(e, "An unexpected error occurred");
var result = Result.Failure(HttpStatusCode.InternalServerError, message: "Internal server error.");
var json = jsonSerializer.Serialize(result);
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.OK;
await context.Response.WriteAsync(json).ConfigureAwait(false);
}
}
protected virtual string GetScriptCode(TagHelperContext context, EasySelectorAttribute easySelectorAttribute)
{
var currentValues = context.Items.First(x => !(x.Key is string)).Value;
var placeHolder = TagHelper.AspFor.Metadata.Placeholder;
var tagId = TagHelper.AspFor.Name.Replace('.', '_');
var subTextContent = easySelectorAttribute.HideSubText
? ""
: " + '<a class=\"selection-subtext\">' + state.id + '</a>'";
var innerCode = $"$(function () {{ let currentValues = {_jsonSerializer.Serialize(currentValues)}; function stringMatch(term,candidate){{return candidate&&candidate.toLowerCase().indexOf(term.toLowerCase())>=0}}; function matchCustom(params,data){{if($.trim(params.term)===\"\"){{return data}}if(typeof data.text===\"undefined\"){{return null}}if(stringMatch(params.term,data.text)){{return data}}if(stringMatch(params.term,state.id)){{return data}}return null}}; let select2Item = function (state) {{ return $('<span>' + state.text{subTextContent} + '</span>'); }}; let select2Option = {{ allowClear: true, width: \"100%\", matcher: matchCustom, templateResult: select2Item, templateSelection: select2Item, ajax: {{ url: '{easySelectorAttribute.GetListedDataSourceUrl}', dataType: \"json\", delay: 250, data: function (params) {{ params.page = params.page || 1; return {{ filter: params.term, skipCount: (params.page - 1) * {easySelectorAttribute.MaxResultCount}, maxResultCount: {easySelectorAttribute.MaxResultCount}, }} }}, processResults: function (data, params) {{ params.page = params.page || 1; return {{ results: data.items.map(function (item) {{ return {{ id: item.{easySelectorAttribute.KeyPropertyName}, text: item.{easySelectorAttribute.TextPropertyName} ?? item.{easySelectorAttribute.AlternativeTextPropertyName} }} }}), pagination: {{ more: (params.page * {easySelectorAttribute.MaxResultCount}) < data.totalCount }} }}; }}, cache: true }}, placeholder: {{ id: '', text: '{placeHolder}' }} }}; $(\"#{tagId}\").select2(select2Option); currentValues && currentValues.values.forEach(function(e) {{ if (!$(\"#{tagId}\").find('option:contains(' + e + ')').length && (e != \"00000000-0000-0000-0000-000000000000\" && e != \"\" && e != \"0\")) abp.ajax({{ type: 'GET', url: '{easySelectorAttribute.GetSingleDataSourceUrl}'.replace('{{id}}', e), success: function (result) {{ $(\"#{tagId}\").append($('<option value=\"' + e + '\">').text(result.{easySelectorAttribute.TextPropertyName} ?? result.{easySelectorAttribute.AlternativeTextPropertyName})); $(\"#{tagId}\").val(currentValues.values).trigger('change'); }}}}); }}); }});";
return(easySelectorAttribute.RunScriptOnWindowLoad
? $"<script>window.addEventListener('load', function() {{{innerCode}}}, false)</script>"
: $"<script>{innerCode}</script>");
}
/// <summary>
/// Grades the submission.
/// </summary>
private async Task <ScoredQuestionResult> GradeSubmission(
QuestionSubmission submission,
Question resolvedQuestion,
UserQuestionData userQuestionData,
UserQuestionStatus userQuestionStatus,
DateTime submissionDate)
{
if (!userQuestionStatus.AllowNewAttempt)
{
throw new InvalidOperationException("No attempts remaining.");
}
var scoredQuestionResult = await GradeQuestionAsync
(
resolvedQuestion,
submission
);
if (userQuestionData.Submissions == null)
{
userQuestionData.Submissions = new List <UserQuestionSubmission>();
}
var submissionContents = _jsonSerializer.Serialize(submission);
var savedSubmission = new UserQuestionSubmission()
{
Score = scoredQuestionResult.Score,
DateSubmitted = submissionDate,
Seed = userQuestionData.Seed,
CachedQuestionData = userQuestionData.CachedQuestionData,
SubmissionContents = submissionContents
};
userQuestionData.Submissions.Add(savedSubmission);
userQuestionData.NumAttempts++;
userQuestionData.Seed = null;
if (userQuestionData.AssignmentQuestion.IsInteractive())
{
userQuestionData.LastQuestionSubmission = submissionContents;
}
return(scoredQuestionResult);
}
/// <summary>
/// Makes an HTTP POST request to the given Uri and serializes the given payload into the content of the request as an "application/json" media type.
/// </summary>
public static async Task <HttpResponseMessage> PostJsonAsync(
this Uri uri,
object payload,
IJsonSerializer jsonSerializer,
CancellationToken token = default)
{
using (var httpClient = new HttpClient())
{
// Serialize the content
var payloadWriter = new StringWriter();
jsonSerializer.Serialize(payloadWriter, payload);
var content = new StringContent(payloadWriter.ToString(), Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync(uri, content, token);
response.EnsureSuccessStatusCode();
return(response);
}
}
private async Task SaveConfigFileAsync()
{
try
{
if (!Directory.Exists(Path.GetDirectoryName(_configFile)))
{
Directory.CreateDirectory(Path.GetDirectoryName(_configFile));
}
var json = _jsonSerializer.Serialize(_widgetConfigurationData);
await File.WriteAllTextAsync(_configFile, json);
Thread.Sleep(10);
}
catch (Exception)
{
}
}
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) {
var data = serializer.Serialize(description);
HttpWebResponse response;
try {
var request = CreateHttpWebRequest(config, String.Format("events/by-ref/{0}/user-description", referenceId));
response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse;
} catch (AggregateException aex) {
var ex = aex.GetInnermostException() as WebException;
if (ex != null)
response = (HttpWebResponse)ex.Response;
else
return new SubmissionResponse(500, message: aex.GetMessage());
} catch (Exception ex) {
return new SubmissionResponse(500, message: ex.Message);
}
return new SubmissionResponse((int)response.StatusCode, response.IsSuccessful() ? null : response.GetResponseText());
}
public Task PublishAsync <T>(T data, string client) where T : class
{
if (data is null)
{
return(Task.CompletedTask);
}
if (_clientResults.Count == 0)
{
return(Task.CompletedTask);
}
var payload = _jsonSerializer.Serialize(data);
if (string.IsNullOrWhiteSpace(client))
{
foreach (var(_, results) in _clientResults)
{
try
{
results.TryAdd(payload);
}
catch (Exception ex)
{
if (_logger.IsError)
{
_logger.Error(ex.Message, ex);
}
}
}
return(Task.CompletedTask);
}
if (!_clientResults.TryGetValue(client, out var clientResult))
{
return(Task.CompletedTask);
}
clientResult.Add(payload);
return(Task.CompletedTask);
}
protected virtual void HandleAndWrapException(ExceptionContext context)
{
//TODO: Trigger an AbpExceptionHandled event or something like that.
context.HttpContext.Response.Headers.Add(AbpHttpConsts.AbpErrorFormat, "true");
context.HttpContext.Response.StatusCode = (int)_statusCodeFinder.GetStatusCode(context.HttpContext, context.Exception);
var remoteServiceErrorInfo = _errorInfoConverter.Convert(context.Exception);
context.Result = new ObjectResult(new RemoteServiceErrorResponse(remoteServiceErrorInfo));
var logLevel = context.Exception.GetLogLevel();
Logger.LogWithLevel(logLevel, $"---------- {nameof(RemoteServiceErrorInfo)} ----------");
Logger.LogWithLevel(logLevel, _jsonSerializer.Serialize(remoteServiceErrorInfo, indented: true));
Logger.LogException(context.Exception, logLevel);
context.Exception = null; //Handled!
}
public async ValueTask SetItemAsync <T>(string key, T data)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException(nameof(key));
}
var e = await RaiseOnChangingAsync(key, data).ConfigureAwait(false);
if (e.Cancel)
{
return;
}
var serialisedData = _serializer.Serialize(data);
await _storageProvider.SetItemAsync(key, serialisedData).ConfigureAwait(false);
RaiseOnChanged(key, e.OldValue, data);
}
public async Task CollectAsync(CliAnalyticsCollectInputDto input)
{
var postData = _jsonSerializer.Serialize(input);
using (var client = new CliHttpClient())
{
var responseMessage = await client.PostAsync(
$"{CliUrls.WwwAbpIo}api/clianalytics/collect",
new StringContent(postData, Encoding.UTF8, MimeTypes.Application.Json),
_cancellationTokenProvider.Token
);
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogInformation("Remote server returns error! HTTP status code: " +
responseMessage.StatusCode);
}
}
}
public TResult Post <TContent, TResult>(string url, TContent content)
{
if (string.IsNullOrWhiteSpace(url))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(url));
}
using (var client = CreateClient())
{
var response = client.PostAsync(
url,
new StringContent(
_serializer.Serialize(content),
Encoding.UTF8,
"application/json")).Result;
return(HandleResponse <TResult>(response));
}
}
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) {
var data = serializer.Serialize(description);
HttpWebResponse response;
try {
var request = CreateHttpWebRequest(config, String.Format("events/by-ref/{0}/user-description", referenceId));
response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse;
} catch (AggregateException aex) {
var ex = aex.GetInnermostException() as WebException;
if (ex != null)
response = (HttpWebResponse)ex.Response;
else
return new SubmissionResponse(500, message: aex.GetMessage());
} catch (Exception ex) {
return new SubmissionResponse(500, message: ex.Message);
}
int settingsVersion;
if (Int32.TryParse(response.Headers[ExceptionlessHeaders.ConfigurationVersion], out settingsVersion))
SettingsManager.CheckVersion(settingsVersion, config);
return new SubmissionResponse((int)response.StatusCode, GetResponseMessage(response));
}
public SubmissionResponse PostEvents(IEnumerable<Event> events, ExceptionlessConfiguration config, IJsonSerializer serializer) {
var data = serializer.Serialize(events);
HttpWebResponse response;
try {
var request = CreateHttpWebRequest(config, "events");
response = request.PostJsonAsyncWithCompression(data).Result as HttpWebResponse;
} catch (AggregateException aex) {
var ex = aex.GetInnermostException() as WebException;
if (ex != null)
response = (HttpWebResponse)ex.Response;
else
return new SubmissionResponse(500, message: aex.GetMessage());
} catch (Exception ex) {
return new SubmissionResponse(500, message: ex.Message);
}
int settingsVersion;
if (Int32.TryParse(response.Headers[ExceptionlessHeaders.ConfigurationVersion], out settingsVersion))
SettingsManager.CheckVersion(settingsVersion, config);
return new SubmissionResponse((int)response.StatusCode, GetResponseMessage(response));
}
private static void WriteProject(XProject project, ZipArchiveEntry projectEntry, IFileSystem fileIO, IJsonSerializer serializer)
{
using (var jsonStream = projectEntry.Open())
{
fileIO.WriteUtf8Text(jsonStream, serializer.Serialize(project));
}
}
public SubmissionResponse PostUserDescription(string referenceId, UserDescription description, ExceptionlessConfiguration config, IJsonSerializer serializer) {
string data = serializer.Serialize(description);
_userDescriptionContainer[referenceId] = data;
return new SubmissionResponse(200);
}
/// <summary>
/// 设置远程异常
/// </summary>
/// <param name="serializer">序列化工具</param>
/// <param name="exceptionContext">上下文</param>
/// <returns></returns>
public static bool SetRemoteException(IJsonSerializer serializer, ExceptionContext exceptionContext)
{
try
{
var packet = exceptionContext.Packet;
packet.state = false;
packet.body = exceptionContext.Exception.Message;
var packetJson = serializer.Serialize(packet);
exceptionContext.Session.SendText(packetJson);
return true;
}
catch (Exception)
{
return false;
}
}
