/// <inheritdoc />
protected override async Task <int> OnExecute(CommandLineApplication app)
{
if (!CheckParameters())
{
return(1);
}
var export = GetInput();
if (export is null)
{
Output.WriteError("input failed to validate");
return(1);
}
var utf8Bytes = JsonSerializer.SerializeToUtf8Bytes(export);
// name / filename must match parameter-name of ImportController.Import
var formData = new MultipartFormDataContent {
{ new ByteArrayContent(utf8Bytes), "file", "file" }
};
var request = await RestRequest.Make(Output)
.Post(new Uri(new Uri(ConfigServiceEndpoint), "v1/import"), formData)
.ReceiveString();
if (request.HttpResponseMessage?.IsSuccessStatusCode != true)
{
Output.WriteError($"couldn't import '{string.Join(", ", Files)}': {request.HttpResponseMessage?.StatusCode:D} {await request.Take<string>()}");
return(1);
}
return(0);
}
static TransformedEvent?HandleResponse(JsValue result, TransformEvent original)
{
if (result == null || result.IsUndefined())
{
Log.Debug("Got empty response, ignoring");
return(null);
}
ObjectInstance obj = result.AsObject();
if (!TryGetString("Stream", true, out var stream) ||
string.IsNullOrWhiteSpace(stream) ||
!TryGetString("EventType", true, out var eventType) ||
string.IsNullOrWhiteSpace(eventType))
{
return(null);
}
var data = GetSerializedObject("Data");
if (data == null)
{
return(null);
}
var meta = GetSerializedObject("Meta");
return(new TransformedEvent(stream, eventType, data, meta));
byte[]? GetSerializedObject(string propName)
{
var candidate = obj.Get(propName);
if (candidate == null || !candidate.IsObject())
{
return(null);
}
return(JsonSerializer.SerializeToUtf8Bytes(candidate.ToObject()));
}
bool TryGetString(string propName, bool log, out string value)
{
var candidate = obj.Get(propName);
if (candidate == null || !candidate.IsString())
{
if (log)
{
Log.Debug("Transformed object property {Prop} is null or not a string", propName);
}
value = string.Empty;
return(false);
}
value = candidate.AsString();
return(true);
}
}
void VerifyDoubleUnicode()
{
var data = $"Hello Unicode: {(char)0xD800}{(char)0xDC00}";
var parameter = Writer.Default.Get(data).Open();
Encoder.Default.Get(parameter)
.Should()
.Be(JsonConvert.ToString(data));
parameter.Should().NotEqual(JsonSerializer.SerializeToUtf8Bytes(data));
}
void VerifyUnicode()
{
const string data = "Hello World!\nHello World Again: 方!";
var parameter = Writer.Default.Get(data).Open();
Encoder.Default.Get(parameter)
.Should()
.Be(JsonConvert.ToString(data));
parameter.Should().NotEqual(JsonSerializer.SerializeToUtf8Bytes(data));
}
public void TestJsonSerialization()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
server.OnDataReceive += (sender, message) => message.Client.Send(message);
using var client = new EasyTcpClient
{
Serialize = o => JsonSerializer.SerializeToUtf8Bytes(o),
Deserialize = (b, t) => JsonSerializer.Deserialize(b, t)
};
Assert.IsTrue(client.Connect(IPAddress.Loopback, port));
var testData = new List <string> {
"testdata", "testdata2"
};
var reply = client.SendAndGetReply(testData);
Assert.AreEqual(testData, reply.Deserialize <List <string> >());
}
public void Publish <T>(T @event) where T : IntegrationEvent
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(ex, time) =>
{
_logger.LogWarning(ex,
"Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})",
@event.Id,
$"{time.TotalSeconds:n1}", ex.Message);
});
var eventName = @event.GetType().Name;
using var channel = _persistentConnection.CreateModel();
channel.ExchangeDeclare(exchange: BROKER_NAME, type: "direct");
var body = JsonSerializer.SerializeToUtf8Bytes(@event);
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 1; // non-persistent
channel.BasicPublish(
exchange: BROKER_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body);
});
}
public string SystemTextJsonUTF8()
{
return(System.Text.UTF8Encoding.UTF8.GetString(JsonSerializer.SerializeToUtf8Bytes(_instance)));
}
private string EncryptToken(AuthTokenResponse token, byte[] salt) =>
Convert.ToBase64String(
ProtectedData.Protect(
JsonSerializer.SerializeToUtf8Bytes(token),
salt,
DataProtectionScope.CurrentUser));
public async Task <IActionResult> DownloadPersonalData()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
_logger.LogInformation("User with ID '{UserId}' asked for their personal data.", _userManager.GetUserId(User));
// Only include personal data for download
var personalData = new Dictionary <string, string>();
var personalDataProps = typeof(IdentityUser).GetProperties().Where(
prop => Attribute.IsDefined(prop, typeof(PersonalDataAttribute)));
foreach (var p in personalDataProps)
{
try
{
var getValue = p.GetValue(user)?.ToString() ?? "null";
personalData.Add(p.Name, getValue);
}
catch (Exception)
{
//ignore
}
}
var logins = await _userManager.GetLoginsAsync(user);
foreach (var l in logins)
{
personalData.Add($"{l.LoginProvider} external login provider key", l.ProviderKey);
}
var id = await _steamIdentityService.FindOne(user.Id);
var AdditionalData = new Dictionary <string, IEnumerable>();
if (id != null)
{
AdditionalData.Add("HistorySteam", (await _pavlovServerPlayerHistoryService.FindAllFromPlayer(id.Id)));
AdditionalData.Add("MatchesSteam", (await _matchService.PersonalStats(id.Id)));
AdditionalData.Add("LeaderBoardSteam", (await _steamIdentityStatsServerService.GetForSteamId(id.Id)));
}
if (id != null && id.OculusId != "" && await _steamIdentityService.FindOne(id.OculusId) == null)
{
AdditionalData.Add("HistoryOculus", (await _pavlovServerPlayerHistoryService.FindAllFromPlayer(id.OculusId)));
AdditionalData.Add("MatchesOculus", (await _matchService.PersonalStats(id.OculusId)));
AdditionalData.Add("LeaderBoardOculus", (await _steamIdentityStatsServerService.GetForSteamId(id.OculusId)));
}
personalData.Add($"Authenticator Key", await _userManager.GetAuthenticatorKeyAsync(user));
Response.Headers.Add("Content-Disposition", "attachment; filename=PersonalData.json");
return(new FileContentResult(JsonSerializer.SerializeToUtf8Bytes(new
{
internalData = personalData,
additionalData = AdditionalData
}), "application/json"));
}
void VerifyEscape()
{
const string data = "Hello World!\nHello World Again!";
Writer.Default.Get(data).Open().Should().Equal(JsonSerializer.SerializeToUtf8Bytes(data));
}
void Verify()
{
var data = string.Join('-', Enumerable.Repeat("Hello World!", 1000));
Writer.Default.Get(data).Open().Should().Equal(JsonSerializer.SerializeToUtf8Bytes(data));
}
