async void CreatePermissionAsync(object resource, RequestOptions requestOptions)
{
try
{
var permission = JsonSerializable.LoadFrom <Permission>(new MemoryStream(Encoding.UTF8.GetBytes(resource as string)));
ResourceResponse <Permission> newtpermission;
using (PerfStatus.Start("CreatePermission"))
{
newtpermission = await _client.CreatePermissionAsync((Parent.Tag as Resource).GetLink(_client), permission, requestOptions);
}
Nodes.Add(new ResourceNode(_client, newtpermission.Resource, ResourceType.Permission));
// set the result window
var json = newtpermission.Resource.ToString();
Program.GetMain().SetResultInBrowser(json, null, false, newtpermission.ResponseHeaders);
}
catch (AggregateException e)
{
Program.GetMain().SetResultInBrowser(null, e.InnerException.ToString(), true);
}
catch (Exception e)
{
Program.GetMain().SetResultInBrowser(null, e.ToString(), true);
}
}
public void GameStart(int gameId, int playerId, int teamId, string trumpCard, int trumpCardPlayer, string[] cards)
{
if (id == playerId)
{
moveCounter = 0;
SuecaTypes.Card sharedTrumpCard = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(trumpCard);
SuecaSolver.Rank trumpRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), sharedTrumpCard.Rank.ToString());
SuecaSolver.Suit trumpSuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), sharedTrumpCard.Suit.ToString());
int myTrumpCard = SuecaSolver.Card.Create(trumpRank, trumpSuit);
this.teamId = teamId;
List <int> initialCards = new List <int>();
Console.Write("GameStart cards: ");
foreach (string cardSerialized in cards)
{
SuecaTypes.Card card = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(cardSerialized);
SuecaSolver.Rank myRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), card.Rank.ToString());
SuecaSolver.Suit mySuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), card.Suit.ToString());
int myCard = SuecaSolver.Card.Create(myRank, mySuit);
Console.Write(SuecaSolver.Card.ToString(myCard) + " ");
initialCards.Add(myCard);
}
Console.WriteLine("");
ai = new RBOPlayer(playerId, initialCards, myTrumpCard, trumpCardPlayer);
allSet = true;
processingRepeat = false;
iaPublisher.ForwardGameStart(gameId, playerId, teamId, trumpCard, trumpCardPlayer, cards);
}
}
private static void _DeserializeExtensions(JsonSerializable parent, ref Utf8JsonReader reader, IList <JsonSerializable> extensions)
{
reader.Read();
if (reader.TokenType == JsonToken.StartObject)
{
while (reader.Read() && reader.TokenType != JsonToken.EndObject)
{
var key = reader.GetString();
var val = ExtensionsFactory.Create(parent, key);
if (val == null)
{
val = new UnknownNode(key);
}
val.Deserialize(ref reader);
extensions.Add(val);
continue;
}
}
reader.Skip();
}
public void LoadPrefabs()
{
var directory = EngineSettings.GetSettingsSubDirectory("Prefabs");
var files = Directory.GetFiles(directory, "*.bspref");
CurrentProject.Prefabs.Clear();
foreach (var file in files)
{
var prefab = JsonSerializable.Load <BlueSwitchProject>(file);
CurrentProject.Prefabs.Add(new Prefab {
Project = prefab, Name = prefab.Name, Description = prefab.Description, FilePath = prefab.FilePath
});
}
foreach (var p in CurrentProject.Prefabs)
{
PrefabSwitch sw = new PrefabSwitch();
sw.Prefab = p;
sw.InitializeMetaInformation(this);
sw.Initialize(this);
sw.AutoDiscoverDisabled = false;
var available = AvailableSwitches.FirstOrDefault(x => x.GetType() == sw.GetType());
// This should probably be refactored to a central spot for AvailableSwitches
if (available != null)
{
AvailableSwitches.Remove(available); // Refresh prefab switches from list
}
AvailableSwitches.Add(sw);
}
}
public void GameStart(int gameId, int playerId, int teamId, string trumpCard, int trumpCardPlayer, string[] cards)
{
_initialyzing = true;
SuecaEvent ev = new SuecaEvent(Consts.STATE_GAME_START);
_suecaRPC.AddSuecaEvent(ev);
ev.AddPropertyChange(Consts.DIALOGUE_STATE_PROPERTY, Consts.STATE_GAME_START, Consts.DEFAULT_SUBJECT);
ev.Finished = true;
List <int> initialCards = new List <int>();
foreach (string cardSerialized in cards)
{
SuecaTypes.Card card = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(cardSerialized);
SuecaSolver.Rank myRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), card.Rank.ToString());
SuecaSolver.Suit mySuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), card.Suit.ToString());
int myCard = SuecaSolver.Card.Create(myRank, mySuit);
initialCards.Add(myCard);
}
SuecaTypes.Card sharedTrumpCard = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(trumpCard);
SuecaSolver.Rank trumpRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), sharedTrumpCard.Rank.ToString());
SuecaSolver.Suit trumpSuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), sharedTrumpCard.Suit.ToString());
int myTrumpCard = SuecaSolver.Card.Create(trumpRank, trumpSuit);
_ai = new RuleBasedPlayer(playerId, initialCards, myTrumpCard, trumpCardPlayer);
_initialyzing = false;
}
private static IReadOnlyDictionary <string, JsonSerializable> _ToDictionary(JsonSerializable context, IEnumerable <JsonSerializable> serializables)
{
var dict = new Dictionary <string, JsonSerializable>();
foreach (var val in serializables)
{
if (val == null)
{
continue;
}
string key = null;
if (val is UnknownNode unk)
{
key = unk.Name;
}
else
{
key = ExtensionsFactory.Identify(context.GetType(), val.GetType());
}
if (key == null)
{
continue;
}
dict[key] = val;
}
return(dict);
}
/// <summary>
/// Tests that the PA-local data format applies when a variable is set in
/// the context of it
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPaLocalFormatApplies() throws com.fasterxml.jackson.core.JsonProcessingException, java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testPaLocalFormatApplies()
{
// given a process instance
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.runtime.ProcessInstance pi = runtimeService.startProcessInstanceByKey("testProcess");
ProcessInstance pi = runtimeService.startProcessInstanceByKey("testProcess");
// when setting a variable in the context of a process application
DateTime date = new DateTime(JsonSerializable.ONE_DAY_IN_MILLIS * 10); // 10th of January 1970
JsonSerializable jsonSerializable = new JsonSerializable(date);
try
{
ProcessApplicationContext.CurrentProcessApplication = ReferenceStoringProcessApplication.INSTANCE;
runtimeService.setVariable(pi.Id, "jsonSerializable", Variables.objectValue(jsonSerializable).serializationDataFormat(Variables.SerializationDataFormats.JSON).create());
}
finally
{
ProcessApplicationContext.clear();
}
// then the process-application-local data format has been used to serialize the value
ObjectValue objectValue = runtimeService.getVariableTyped(pi.Id, "jsonSerializable", false);
string serializedValue = objectValue.ValueSerialized;
string expectedSerializedValue = jsonSerializable.toExpectedJsonString(JsonDataFormatConfigurator.DATE_FORMAT);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode actualJsonTree = objectMapper.readTree(serializedValue);
JsonNode expectedJsonTree = objectMapper.readTree(expectedSerializedValue);
// JsonNode#equals makes a deep comparison
Assert.assertEquals(expectedJsonTree, actualJsonTree);
}
/// <summary>
/// Adds a json serializable object to the parameters
/// </summary>
/// <param name="jsonSerializable"></param>
/// <returns></returns>
public Request AddParameter(JsonSerializable jsonSerializable)
{
if (jsonSerializable == null)
{
throw new ArgumentNullException(nameof(jsonSerializable));
}
Params.Add(jsonSerializable.ToJsonObject());
return(this);
}
public async Task Create(JObject data)
{
var bytes = Encoding.UTF8.GetBytes(data.ToString());
using (var ms = new MemoryStream(bytes))
{
await _client.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(_database, _collection),
JsonSerializable.LoadFrom <Document>(ms));
}
}
public void LoadSettings()
{
try
{
Settings = JsonSerializable.Load <EngineSettings>(EngineSettings.SettingsFilePath);
}
catch
{
Settings = new EngineSettings();
Settings.Save(EngineSettings.SettingsFilePath);
}
}
private static T DirectDeSerialize <T>(string payload) where T : JsonSerializable, new()
{
using (MemoryStream ms = new MemoryStream())
{
StreamWriter sw = new StreamWriter(ms, new UTF8Encoding(false, true), 1024, leaveOpen: true);
sw.Write(payload);
sw.Flush();
ms.Position = 0;
return(JsonSerializable.LoadFrom <T>(ms));
}
}
private void SaveToFile()
{
RankContainer container = new RankContainer();
container.stageID = Program.MainForm.ConfigEditor.currentID;
container.normalMission.SonicA = (ushort)NumericSonicA.Value;
container.normalMission.SonicB = (ushort)NumericSonicB.Value;
container.normalMission.SonicC = (ushort)NumericSonicC.Value;
container.normalMission.SonicD = (ushort)NumericSonicD.Value;
container.normalMission.DarkA = (ushort)NumericDarkA.Value;
container.normalMission.DarkB = (ushort)NumericDarkB.Value;
container.normalMission.DarkC = (ushort)NumericDarkC.Value;
container.normalMission.DarkD = (ushort)NumericDarkD.Value;
container.normalMission.RoseA = (ushort)NumericRoseA.Value;
container.normalMission.RoseB = (ushort)NumericRoseB.Value;
container.normalMission.RoseC = (ushort)NumericRoseC.Value;
container.normalMission.RoseD = (ushort)NumericRoseD.Value;
container.normalMission.ChaotixA = (ushort)NumericChaotixA.Value;
container.normalMission.ChaotixB = (ushort)NumericChaotixB.Value;
container.normalMission.ChaotixC = (ushort)NumericChaotixC.Value;
container.normalMission.ChaotixD = (ushort)NumericChaotixD.Value;
container.extraMissionScore.SonicA = (ushort)NumericSonicEA.Value;
container.extraMissionScore.SonicB = (ushort)NumericSonicEB.Value;
container.extraMissionScore.SonicC = (ushort)NumericSonicEC.Value;
container.extraMissionScore.SonicD = (ushort)NumericSonicED.Value;
container.extraMissionScore.ChaotixA = (ushort)NumericChaotixEA.Value;
container.extraMissionScore.ChaotixB = (ushort)NumericChaotixEB.Value;
container.extraMissionScore.ChaotixC = (ushort)NumericChaotixEC.Value;
container.extraMissionScore.ChaotixD = (ushort)NumericChaotixED.Value;
container.extraMissionTime.DarkAMin = (byte)NumericDarkEAMin.Value;
container.extraMissionTime.DarkBMin = (byte)NumericDarkEBMin.Value;
container.extraMissionTime.DarkCMin = (byte)NumericDarkECMin.Value;
container.extraMissionTime.DarkDMin = (byte)NumericDarkEDMin.Value;
container.extraMissionTime.RoseAMin = (byte)NumericRoseEAMin.Value;
container.extraMissionTime.RoseBMin = (byte)NumericRoseEBMin.Value;
container.extraMissionTime.RoseCMin = (byte)NumericRoseECMin.Value;
container.extraMissionTime.RoseDMin = (byte)NumericRoseEDMin.Value;
container.extraMissionTime.DarkASec = (byte)NumericDarkEASec.Value;
container.extraMissionTime.DarkBSec = (byte)NumericDarkEBSec.Value;
container.extraMissionTime.DarkCSec = (byte)NumericDarkECSec.Value;
container.extraMissionTime.DarkDSec = (byte)NumericDarkEDSec.Value;
container.extraMissionTime.RoseASec = (byte)NumericRoseEASec.Value;
container.extraMissionTime.RoseBSec = (byte)NumericRoseEBSec.Value;
container.extraMissionTime.RoseCSec = (byte)NumericRoseECSec.Value;
container.extraMissionTime.RoseDSec = (byte)NumericRoseEDSec.Value;
JsonSerializable <RankContainer> .ToPath(container, rankJsonPath);
}
public void GameStart(int gameId, int playerId, int teamId, string trumpCard, int trumpCardPlayer, string[] cards, int floorId)
{
int playerID1 = _randomNumberGenerator.Next(1, 2);
int playerID2 = ((playerID1 + 1) % 2);
SuecaPub.GazeAtTarget("player" + playerID1);
if (playerId == _id)
{
_initialyzing = true;
_teamId = teamId;
_currentGameId = gameId;
_currentTrickId = 0;
_currentPlayInTrickId = 0;
if (gameId != 0)
{
//Console.WriteLine("next games");
SuecaEvent ev = new SuecaEvent(Consts.STATE_GAME_START);
_suecaRPC.AddSuecaEvent(ev);
ev.AddPropertyChange(Consts.DIALOGUE_STATE_PROPERTY, Consts.STATE_GAME_START, Consts.DEFAULT_SUBJECT);
ev.AddPropertyChange(Consts.DIALOGUE_FLOOR_PROPERTY, floorId.ToString(), Consts.DEFAULT_SUBJECT);
ev.ChangeTagsAndMeanings(new string[] { "|playerID1|", "|playerID2|" }, new string[] { playerID1.ToString(), playerID2.ToString() });
ev.Finished = true;
}
List <int> initialCards = new List <int>();
foreach (string cardSerialized in cards)
{
SuecaTypes.Card card = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(cardSerialized);
SuecaSolver.Rank myRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), card.Rank.ToString());
SuecaSolver.Suit mySuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), card.Suit.ToString());
int myCard = SuecaSolver.Card.Create(myRank, mySuit);
initialCards.Add(myCard);
}
SuecaTypes.Card sharedTrumpCard = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(trumpCard);
SuecaSolver.Rank trumpRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), sharedTrumpCard.Rank.ToString());
SuecaSolver.Suit trumpSuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), sharedTrumpCard.Suit.ToString());
int myTrumpCard = SuecaSolver.Card.Create(trumpRank, trumpSuit);
if (_nameId == 1)
{
_ai = new RBOPlayer(playerId, initialCards, myTrumpCard, trumpCardPlayer);
}
else if (_nameId == 2)
{
_ai = new RKOPlayer(playerId, initialCards, myTrumpCard, trumpCardPlayer);
}
Console.WriteLine("MY NAME IS {0}.", _nameId);
_initialyzing = false;
}
}
public override void ReplaceEvent(object docId, AuditEvent auditEvent)
{
var client = GetClient();
var docUri = UriFactory.CreateDocumentUri(_database, _collection, docId.ToString());
Document doc;
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(auditEvent.ToJson())))
{
doc = JsonSerializable.LoadFrom <Document>(ms);
doc.Id = docId.ToString();
}
client.ReplaceDocumentAsync(docUri, doc).Wait();
}
// This function will get triggered/executed when a new message is written in the servicebus output queue
public static void ProcessQueueMessage([ServiceBusTrigger("outputqueue", AccessRights.Listen)] BrokeredMessage message, TextWriter log)
{
try
{
var stream = message.GetBody <Stream>();
var document = JsonSerializable.LoadFrom <Document>(stream);
Client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(DbName, CollectionName), document).Wait();
}
catch (Exception e)
{
log.WriteLine(e.Message);
}
}
public override async Task ReplaceEventAsync(object docId, AuditEvent auditEvent)
{
var client = GetClient(auditEvent);
var docUri = UriFactory.CreateDocumentUri(DatabaseBuilder?.Invoke(auditEvent), CollectionBuilder?.Invoke(auditEvent), docId.ToString());
Document doc;
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(auditEvent.ToJson())))
{
doc = JsonSerializable.LoadFrom <Document>(ms);
doc.Id = docId.ToString();
}
await client.ReplaceDocumentAsync(docUri, doc);
}
public void RankEditorOpenConfig()
{
if (File.Exists(rankJsonPath))
{
RankContainer container = JsonSerializable <RankContainer> .FromPath(rankJsonPath);
NumericSonicA.Value = container.normalMission.SonicA;
NumericSonicB.Value = container.normalMission.SonicB;
NumericSonicC.Value = container.normalMission.SonicC;
NumericSonicD.Value = container.normalMission.SonicD;
NumericDarkA.Value = container.normalMission.DarkA;
NumericDarkB.Value = container.normalMission.DarkB;
NumericDarkC.Value = container.normalMission.DarkC;
NumericDarkD.Value = container.normalMission.DarkD;
NumericRoseA.Value = container.normalMission.RoseA;
NumericRoseB.Value = container.normalMission.RoseB;
NumericRoseC.Value = container.normalMission.RoseC;
NumericRoseD.Value = container.normalMission.RoseD;
NumericChaotixA.Value = container.normalMission.ChaotixA;
NumericChaotixB.Value = container.normalMission.ChaotixB;
NumericChaotixC.Value = container.normalMission.ChaotixC;
NumericChaotixD.Value = container.normalMission.ChaotixD;
NumericSonicEA.Value = container.extraMissionScore.SonicA;
NumericSonicEB.Value = container.extraMissionScore.SonicB;
NumericSonicEC.Value = container.extraMissionScore.SonicC;
NumericSonicED.Value = container.extraMissionScore.SonicD;
NumericChaotixEA.Value = container.extraMissionScore.ChaotixA;
NumericChaotixEB.Value = container.extraMissionScore.ChaotixB;
NumericChaotixEC.Value = container.extraMissionScore.ChaotixC;
NumericChaotixED.Value = container.extraMissionScore.ChaotixD;
NumericDarkEAMin.Value = container.extraMissionTime.DarkAMin;
NumericDarkEBMin.Value = container.extraMissionTime.DarkBMin;
NumericDarkECMin.Value = container.extraMissionTime.DarkCMin;
NumericDarkEDMin.Value = container.extraMissionTime.DarkDMin;
NumericRoseEAMin.Value = container.extraMissionTime.RoseAMin;
NumericRoseEBMin.Value = container.extraMissionTime.RoseBMin;
NumericRoseECMin.Value = container.extraMissionTime.RoseCMin;
NumericRoseEDMin.Value = container.extraMissionTime.RoseDMin;
NumericDarkEASec.Value = container.extraMissionTime.DarkASec;
NumericDarkEBSec.Value = container.extraMissionTime.DarkBSec;
NumericDarkECSec.Value = container.extraMissionTime.DarkCSec;
NumericDarkEDSec.Value = container.extraMissionTime.DarkDSec;
NumericRoseEASec.Value = container.extraMissionTime.RoseASec;
NumericRoseEBSec.Value = container.extraMissionTime.RoseBSec;
NumericRoseECSec.Value = container.extraMissionTime.RoseCSec;
NumericRoseEDSec.Value = container.extraMissionTime.RoseDSec;
}
}
public void Play(int id, string card, string playInfo)
{
SuecaTypes.Card c = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(card);
SuecaSolver.Rank myRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), c.Rank.ToString());
SuecaSolver.Suit mySuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), c.Suit.ToString());
int myCard = SuecaSolver.Card.Create(myRank, mySuit);
if (_ai != null && id != this._id)
{
SuecaEvent ev = new SuecaEvent(Consts.STATE_PLAY);
_suecaRPC.AddSuecaEvent(ev);
ev.AddPropertyChange(Consts.CURRENT_PLAYER, checkTeam(id), Consts.DEFAULT_SUBJECT);
_ai.AddPlay(id, myCard);
ev.AddPropertyChange(Consts.DIALOGUE_STATE_PROPERTY, Consts.STATE_PLAY, Consts.DEFAULT_SUBJECT);
string[] tags = new string[] { "|rank|", "|suit|", "|playerId|" };
string[] meanings = new string[] { convertRankToPortuguese(myRank.ToString()), convertSuitToPortuguese(mySuit.ToString()), id.ToString() };
ev.ChangeTagsAndMeanings(tags, meanings);
int currentPlayPoints = _ai.GetCurrentTrickPoints();
bool hasNewTrickWinner = _ai.HasNewTrickTeamWinner();
bool lastPlayOfTrick = _ai.IsLastPlayOfTrick();
ev.AddPropertyChange(Consts.TRICK_SCORE, currentPlayPoints.ToString(), checkTeam(id));
//if (hasNewTrickWinner && !lastPlayOfTrick && !robotHasPlayed)
if (hasNewTrickWinner && !lastPlayOfTrick)
{
int currentWinnerID = _ai.GetCurrentTrickWinner();
string lastPlayInfo = _ai.GetLastPlayInfo();
if (lastPlayInfo == Sueca.PLAY_INFO_NEWTRICK)
{
ev.AddPropertyChange(Consts.TRICK_WINNER, checkTeam(currentWinnerID), Sueca.PLAY_INFO_NEWTRICK);
}
else
{
ev.AddPropertyChange(Consts.TRICK_WINNER, checkTeam(currentWinnerID), checkTeam(id));
}
int trickIncrease = _ai.GetTrickIncrease();
if (trickIncrease > 0)
{
ev.AddPropertyChange(Consts.TRICK_INCREASE_PROPERTY, trickIncrease.ToString(), checkTeam(id));
}
}
ev.Finished = true;
}
}
public void TestSaveAndLoadAppDataFolder()
{
const string AppName = "ZicoreBaseTest";
const string FileName = "Test.json";
var filePath = JsonSerializable.GetAppDataFilePath(FileName, AppName);
// Ensure to delete before test
File.Delete(filePath);
JsonSerialzableTestValues test = new JsonSerialzableTestValues();
try
{
// Assign Test Values
AssignTestValues(test, _testValues);
// Save to file
test.SaveToAppData(FileName, AppName);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
test = new JsonSerialzableTestValues(); // Create new class with different values
try
{
test.LoadFromAppData(FileName, AppName);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
// Test against test values
CompareValues(test, _testValues);
// cleanup test file
try
{
File.Delete(filePath);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
public void LoadProject(String filePath)
{
OnBeforeLoading();
CurrentProject = new BlueSwitchProject();
try
{
CurrentProject = JsonSerializable.Load <BlueSwitchProject>(filePath);
}
catch (Exception ex)
{
_log.Error(ex);
}
LoadPrefabs();
CurrentProject.Initialize(this);
OnProjectLoaded();
}
public override async Task ReplaceEventAsync(object docId, AuditEvent auditEvent)
{
var client = GetClient();
var docUri = UriFactory.CreateDocumentUri(DatabaseBuilder?.Invoke(), ContainerBuilder?.Invoke(), docId.ToString());
Document doc;
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(auditEvent.ToJson())))
{
doc = JsonSerializable.LoadFrom <Document>(ms);
}
doc.Id = docId.ToString();
await client.ReplaceDocumentAsync(docUri, doc, new RequestOptions()
{
JsonSerializerSettings = Core.Configuration.JsonSettings
});
}
public async Task DocumentDB(string collectionName, string resp, TraceWriter llog)
{
try
{
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
var EndpointUrlKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/EndpointUrlKV")
.ConfigureAwait(false);
var PrimaryKeyKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/PrimaryKeyKV")
.ConfigureAwait(false);
var databaseNameKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/databasenameKV")
.ConfigureAwait(false);
client = new DocumentClient(new Uri(EndpointUrlKV.Value), PrimaryKeyKV.Value);
await client.CreateDatabaseIfNotExistsAsync(new Database { Id = databaseNameKV.Value });
try
{
await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(databaseNameKV.Value), new DocumentCollection { Id = collectionName }, new RequestOptions { OfferThroughput = 400 });
}
catch (Exception e)
{
llog.Info("DocumentClientException: " + e.Message.ToString());
}
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(resp)))
{
var doc = JsonSerializable.LoadFrom <Document>(ms);
doc.Id = DateTime.Now.ToLongTimeString() + " " + DateTime.Now.ToLongDateString();
var docDBresp = await client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseNameKV.Value, collectionName), doc);
/*while (docDBresp.IsCompleted == false)
* { }*/
}
}
catch (Exception e)
{
llog.Info("General Exception: " + e.Message.ToString());
}
}
/// <summary>
/// Tests that an implicit object value update happens in the context of the
/// process application.
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testExecutionVariableImplicitObjectValueUpdate() throws com.fasterxml.jackson.core.JsonProcessingException, java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testExecutionVariableImplicitObjectValueUpdate()
{
// given a process instance and a task
ProcessInstance pi = runtimeService.startProcessInstanceByKey("implicitProcessVariableUpdate");
// when setting a variable such that the process-application-local dataformat applies
DateTime date = new DateTime(JsonSerializable.ONE_DAY_IN_MILLIS * 10); // 10th of January 1970
JsonSerializable jsonSerializable = new JsonSerializable(date);
try
{
ProcessApplicationContext.CurrentProcessApplication = ReferenceStoringProcessApplication.INSTANCE;
runtimeService.setVariable(pi.Id, ImplicitObjectValueUpdateHandler.VARIABLE_NAME, Variables.objectValue(jsonSerializable).serializationDataFormat(Variables.SerializationDataFormats.JSON).create());
}
finally
{
ProcessApplicationContext.clear();
}
// and triggering an implicit update of the object value variable
Task task = taskService.createTaskQuery().processInstanceId(pi.Id).singleResult();
taskService.complete(task.Id);
// then the process-application-local format was used for making the update
ObjectValue objectValue = runtimeService.getVariableTyped(pi.Id, ImplicitObjectValueUpdateHandler.VARIABLE_NAME, false);
ImplicitObjectValueUpdateHandler.addADay(jsonSerializable);
string serializedValue = objectValue.ValueSerialized;
string expectedSerializedValue = jsonSerializable.toExpectedJsonString(JsonDataFormatConfigurator.DATE_FORMAT);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode actualJsonTree = objectMapper.readTree(serializedValue);
JsonNode expectedJsonTree = objectMapper.readTree(expectedSerializedValue);
// JsonNode#equals makes a deep comparison
Assert.assertEquals(expectedJsonTree, actualJsonTree);
// and it is also correct in the history
HistoricVariableInstance historicObjectValue = historyService.createHistoricVariableInstanceQuery().processInstanceId(pi.Id).variableName(ImplicitObjectValueUpdateHandler.VARIABLE_NAME).disableCustomObjectDeserialization().singleResult();
serializedValue = ((ObjectValue)historicObjectValue.TypedValue).ValueSerialized;
actualJsonTree = objectMapper.readTree(serializedValue);
Assert.assertEquals(expectedJsonTree, actualJsonTree);
}
public static SerializableNameValueCollection LoadFromString(string value)
{
if (!string.IsNullOrEmpty(value))
{
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(ms))
{
writer.Write(value);
writer.Flush();
ms.Position = 0;
return(JsonSerializable.LoadFrom <SerializableNameValueCollection>(ms));
}
}
}
return(new SerializableNameValueCollection());
}
public Task PutAsync(HttpMonitor httpMonitor)
{
if (httpMonitor == null)
{
throw new ArgumentNullException(nameof(httpMonitor));
}
var documentCollectionUri = _configs.DocumentCollectionUri;
var jObject = JObject.FromObject(httpMonitor, JsonSerializer.Create(Constants.JsonSerializerSettings));
// add type
jObject.Add("_type", JValue.CreateString(DocumentType));
var document = JsonSerializable.LoadFrom <Document>(new MemoryStream(Encoding.UTF8.GetBytes(jObject.ToString())));
return(_client.UpsertDocumentAsync(documentCollectionUri, document, null, true));
}
public async Task Run(string input)
{
var updatedCount = 0;
var query = _documentClient.CreateDocumentQuery <dynamic>(
UriFactory.CreateDocumentCollectionUri(_configuration.DatabaseId, _configuration.VenuesCollectionName),
"select * from venues c where is_defined(c.LATITUDE) or is_defined(c.LONGITUDE) or is_defined(c.ID)")
.AsDocumentQuery();
await query.ProcessAll(async chunk =>
{
foreach (Document doc in chunk)
{
var jObj = JObject.Parse(doc.ToString());
if (jObj.ContainsKey("ID"))
{
jObj.Remove("ID");
}
if (jObj.ContainsKey("LATITUDE"))
{
jObj["Latitude"] = jObj["LATITUDE"];
jObj.Remove("LATITUDE");
}
if (jObj.ContainsKey("LONGITUDE"))
{
jObj["Longitude"] = jObj["LONGITUDE"];
jObj.Remove("LONGITUDE");
}
var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(jObj.ToString()));
var updatedDoc = JsonSerializable.LoadFrom <Document>(jsonStream);
await _documentClient.ReplaceDocumentAsync(updatedDoc);
updatedCount++;
}
});
_logger.LogInformation($"Updated {updatedCount} venues.");
}
public void Play(int id, string card, string playInfo, int floorId)
{
SuecaTypes.Card c = JsonSerializable.DeserializeFromJson <SuecaTypes.Card>(card);
SuecaSolver.Rank myRank = (SuecaSolver.Rank)Enum.Parse(typeof(SuecaSolver.Rank), c.Rank.ToString());
SuecaSolver.Suit mySuit = (SuecaSolver.Suit)Enum.Parse(typeof(SuecaSolver.Suit), c.Suit.ToString());
int myCard = SuecaSolver.Card.Create(myRank, mySuit);
if (_ai != null && id != this._id)
{
SuecaPub.GazeAtTarget("player" + id);
SuecaEvent ev = new SuecaEvent(Consts.STATE_PLAYPARTNER);
_suecaRPC.AddSuecaEvent(ev);
ev.AddPropertyChange(Consts.CURRENT_PLAYER, SubjectName(id), Consts.DEFAULT_SUBJECT);
_ai.AddPlay(id, myCard);
string[] tags = new string[] { "|rank|", "|suit|", "|playerID|", "|nextPlayerID|" };
string[] meanings = new string[] { ConvertRankToPortuguese(myRank.ToString()), ConvertSuitToPortuguese(mySuit.ToString()), id.ToString(), _ai.GetNextPlayerId().ToString() };
ev.ChangeTagsAndMeanings(tags, meanings);
SuecaPub.GazeAtTarget("cardsZone");
if (_ai.GetTrickIncrease() > 0 || _ai.HasNewTrickTeamWinner())
{
ev.AddPropertyChange(Consts.TRICK_INCREASE_PROPERTY, "True", SubjectName(id));
}
else
{
ev.AddPropertyChange(Consts.TRICK_INCREASE_PROPERTY, "False", SubjectName(id));
}
int trickScore = _ai.GetZeroSumTrickScore();
Console.WriteLine("EMYS" + _nameId + " the current trickScore is: " + trickScore);
ev.AddPropertyChange(Consts.TRICK_SCORE, trickScore.ToString(), SubjectName(id));
ev.AddPropertyChange(Consts.DIALOGUE_STATE_PROPERTY, Consts.STATE_PLAYPARTNER, Consts.DEFAULT_SUBJECT);
ev.AddPropertyChange(Consts.DIALOGUE_FLOOR_PROPERTY, floorId.ToString(), Consts.DEFAULT_SUBJECT);
ev.OtherIntInfos = new int[] { id };
ev.Finished = true;
_currentPlayInTrickId++;
}
}
public async Task DocumentDB(string collectionName, string resp)
{
try
{
//use managed service identity to obtain key vault access
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
//read CosmosDB creds from key vault
var EndpointUrlKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/EndpointUrlKV")
.ConfigureAwait(false);
var PrimaryKeyKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/PrimaryKeyKV")
.ConfigureAwait(false);
var databaseNameKV = await keyVaultClient.GetSecretAsync("https://Demo-KV001.vault.azure.net/secrets/databasenameKV")
.ConfigureAwait(false);
client = new DocumentClient(new Uri(EndpointUrlKV.Value), PrimaryKeyKV.Value);
await client.CreateDatabaseIfNotExistsAsync(new Database { Id = databaseNameKV.Value });
await client.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(databaseNameKV.Value), new DocumentCollection { Id = collectionName });
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(resp)))
{
var doc = JsonSerializable.LoadFrom <Document>(ms);
doc.Id = DateTime.Now.ToLongTimeString() + " " + DateTime.Now.ToLongDateString();
var docDBresp = await client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseNameKV.Value, collectionName), doc);
/*while (docDBresp.IsCompleted == false)
* { }*/
}
}
catch (DocumentClientException de)
{
Console.WriteLine("DocumentClientException: {0}", de.Message);
Console.ReadKey();
}
}
public Task CreateAsync(IAlertContact alertContact)
{
if (alertContact == null)
{
throw new ArgumentNullException(nameof(alertContact));
}
var documentcollectionUri = _configs.DocumentCollectionUri;
var jObject = JObject.FromObject(alertContact, JsonSerializer.Create(Constants.JsonSerializerSettings));
// add type
jObject.Add("_type", JValue.CreateString(DocumentType));
var json = jObject.ToString();
var document = JsonSerializable.LoadFrom <Document>(new MemoryStream(Encoding.UTF8.GetBytes(json)));
return(_client.CreateDocumentAsync(documentcollectionUri, document, null, true));
}
public Document GetNextDocument()
{
var data = _streamReader.ReadLine();
if (data != null)
{
// build a Document instance from JSON text
Document document = null;
using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(data)))
{
document = JsonSerializable.LoadFrom <Document>(memoryStream);
}
return(document);
}
else
{
// we've reached the end of the file
return(null);
}
}
