public AsiceArchive(X509Certificate2 cryptographicCertificate, GuidUtility guidUtility, IEnumerable<AsiceAttachableProcessor> asiceAttachableProcessors, params IAsiceAttachable[] asiceAttachables)
{
CryptographicCertificate = cryptographicCertificate;
GuidUtility = guidUtility;
AsiceAttachableProcessors = asiceAttachableProcessors;
AsiceAttachables = asiceAttachables;
UnencryptedBytes = CreateZipFile();
}
/// <summary>
/// Sjekker at motatt soap dokument har samme digest verdier for body og dokumentpakke i avsendt brev vha motatt NonRepudiationInformation element.
/// </summary>
/// <param name="guidHandler">Samme guid handler som ble benyttet for å generere det avsendte brevet.</param>
public void ValiderDigest(GuidUtility guidHandler)
{
string sourceDigestPath = "/env:Envelope/env:Header/wsse:Security/ds:Signature/ds:SignedInfo/ds:Reference[@URI='{0}']/ds:DigestValue";
string targetDigestPath = "/env:Envelope/env:Header/eb:Messaging/eb:SignalMessage/eb:Receipt/ebbp:NonRepudiationInformation/ebbp:MessagePartNRInformation/ds:Reference[@URI='{0}']/ds:DigestValue";
foreach (var uri in new string[] { "#" + guidHandler.BodyId, "cid:" + guidHandler.DokumentpakkeId })
{
string sourceDigest = _sendtMelding.SelectSingleNode(string.Format(sourceDigestPath, uri), nsMgr).InnerText;
string targetDigest = responseDocument.SelectSingleNode(string.Format(targetDigestPath, uri), nsMgr).InnerText;
if (sourceDigest != targetDigest)
throw new Exception(string.Format("Digest verdien av uri {0} for sendt melding ({1}) matcher ikke motatt digest ({2}).", uri, sourceDigest, targetDigest));
}
}
/// <summary>
/// Forespør kvittering for forsendelser med mulighet til å samtidig bekrefte på forrige kvittering for å slippe å kjøre eget kall for bekreft.
/// Kvitteringer blir tilgjengeliggjort etterhvert som de er klare i meldingsformidler. Det er ikke mulig å etterspørre kvittering for en
/// spesifikk forsendelse.
/// </summary>
/// <param name="kvitteringsforespørsel"></param>
/// <param name="forrigeKvittering"></param>
/// <returns></returns>
/// <remarks>
/// <list type="table">
/// <listheader><description>Dersom det ikke er tilgjengelige kvitteringer skal det ventes følgende tidsintervaller før en ny forespørsel gjøres</description></listheader>
/// <item><term>normal</term><description>Minimum 10 minutter</description></item>
/// <item><term>prioritert</term><description>Minimum 1 minutt</description></item>
/// </list>
/// </remarks>
public async Task<Kvittering> HentKvitteringOgBekreftForrigeAsync(Kvitteringsforespørsel kvitteringsforespørsel, Forretningskvittering forrigeKvittering)
{
if (forrigeKvittering != null)
{
Bekreft(forrigeKvittering);
}
Logging.Log(TraceEventType.Information, "Henter kvittering for " + kvitteringsforespørsel.Mpc);
var guidHandler = new GuidUtility();
var envelopeSettings = new EnvelopeSettings(kvitteringsforespørsel, _databehandler, guidHandler);
var kvitteringsenvelope = new KvitteringsforespørselEnvelope(envelopeSettings);
Logging.Log(TraceEventType.Verbose, "Envelope for kvitteringsforespørsel" + Environment.NewLine + kvitteringsenvelope.Xml().OuterXml);
ValiderKvitteringsEnvelope(kvitteringsenvelope);
var soapContainer = new SoapContainer(kvitteringsenvelope);
var kvittering = await SendSoapContainer(soapContainer);
Logg(TraceEventType.Verbose, Guid.Empty , kvitteringsenvelope.Xml().OuterXml, true, true, "Sendt - Kvitteringsenvelope.xml");
try
{
var valideringAvResponsSignatur = new Responsvalidator(kvittering, kvitteringsenvelope.Xml());
valideringAvResponsSignatur.ValiderHeaderSignatur();
valideringAvResponsSignatur.ValiderKvitteringSignatur();
}
catch (Exception e)
{
return ValiderTransportkvittering(kvittering,kvitteringsenvelope.Xml(),guidHandler);
}
return KvitteringFactory.GetForretningskvittering(kvittering);
}
private AsicEArkiv LagAsicEArkiv(Forsendelse forsendelse, bool lagreDokumentpakke, GuidUtility guidHandler)
{
var arkiv = new AsicEArkiv(forsendelse, guidHandler, _databehandler.Sertifikat);
if (lagreDokumentpakke)
{
arkiv.LagreTilDisk(_klientkonfigurasjon.StandardLoggSti, "dokumentpakke",
DateUtility.DateForFile() + " - Dokumentpakke.zip");
}
return arkiv;
}
private void DoWorkspaceOpenAndCompare(string filePath, string dirName,
Func <DynamoModel, string, string> saveFunction,
Action <serializationTestUtils.WorkspaceComparisonData, serializationTestUtils.WorkspaceComparisonData, Dictionary <Guid, String> > workspaceCompareFunction,
Action <serializationTestUtils.WorkspaceComparisonData, string, TimeSpan, Dictionary <Guid, string> > workspaceDataSaveFunction)
{
var openPath = filePath;
if (bannedTests.Any(t => filePath.Contains(t)))
{
Assert.Inconclusive("Skipping test known to kill the test framework...");
}
OpenModel(openPath);
var model = CurrentDynamoModel;
var ws1 = model.CurrentWorkspace;
ws1.Description = "TestDescription";
var dummyNodes = ws1.Nodes.Where(n => n is DummyNode);
if (dummyNodes.Any())
{
Assert.Inconclusive("The Workspace contains dummy nodes for: " + string.Join(",", dummyNodes.Select(n => n.Name).ToArray()));
}
var cbnErrorNodes = ws1.Nodes.Where(n => n is CodeBlockNodeModel && n.State == ElementState.Error);
if (cbnErrorNodes.Any())
{
Assert.Inconclusive("The Workspace contains code block nodes in error state due to which rest " +
"of the graph will not execute; skipping test ...");
}
if (((HomeWorkspaceModel)ws1).RunSettings.RunType == Models.RunType.Manual)
{
RunCurrentModel();
}
var wcd1 = new serializationTestUtils.WorkspaceComparisonData(ws1, CurrentDynamoModel.EngineController);
var dirPath = Path.Combine(Path.GetTempPath(), dirName);
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
var fi = new FileInfo(filePath);
var filePathBase = dirPath + @"\" + Path.GetFileNameWithoutExtension(fi.Name);
serializationTestUtils.ConvertCurrentWorkspaceToDesignScriptAndSave(filePathBase, CurrentDynamoModel);
string json = saveFunction(model, filePathBase);
workspaceDataSaveFunction(wcd1, filePathBase, lastExecutionDuration, modelsGuidToIdMap);
lastExecutionDuration = new TimeSpan();
var ws2 = WorkspaceModel.FromJson(json, model.LibraryServices,
model.EngineController, model.Scheduler, model.NodeFactory, DynamoModel.IsTestMode, false,
model.CustomNodeManager);
if (ws2 is CustomNodeWorkspaceModel)
{
model.AddCustomNodeWorkspace((CustomNodeWorkspaceModel)ws2);
}
foreach (var c in ws2.Connectors)
{
Assert.NotNull(c.Start.Owner, "The node is not set for the start of connector " + c.GUID + ". The end node is " + c.End.Owner + ".");
Assert.NotNull(c.End.Owner, "The node is not set for the end of connector " + c.GUID + ". The start node is " + c.Start.Owner + ".");
}
// The following logic is taken from the DynamoModel.Open method.
// It assumes a single home workspace model. So, we remove all
// others, before adding a new one.
if (ws2 is HomeWorkspaceModel)
{
var currentHomeSpaces = model.Workspaces.OfType <HomeWorkspaceModel>().ToList();
if (currentHomeSpaces.Any())
{
var end = ws2 is HomeWorkspaceModel ? 0 : 1;
for (var i = currentHomeSpaces.Count - 1; i >= end; i--)
{
model.RemoveWorkspace(currentHomeSpaces[i]);
}
}
model.AddWorkspace(ws2);
var hws = ws2 as HomeWorkspaceModel;
if (hws != null)
{
model.ResetEngine();
if (hws.RunSettings.RunType == RunType.Periodic)
{
hws.StartPeriodicEvaluation();
}
}
model.CurrentWorkspace = ws2;
}
Assert.NotNull(ws2);
dummyNodes = ws2.Nodes.Where(n => n is DummyNode);
if (dummyNodes.Any())
{
Assert.Inconclusive("The Workspace contains dummy nodes for: " + string.Join(",", dummyNodes.Select(n => n.Name).ToArray()));
}
var wcd2 = new serializationTestUtils.WorkspaceComparisonData(ws2, CurrentDynamoModel.EngineController);
workspaceCompareFunction(wcd1, wcd2, modelsGuidToIdMap);
var functionNodes = ws2.Nodes.Where(n => n is Function).Cast <Function>();
if (functionNodes.Any())
{
Assert.True(functionNodes.All(n => CurrentDynamoModel.CustomNodeManager.LoadedDefinitions.Contains(n.Definition)));
}
foreach (var c in ws2.Connectors)
{
Assert.NotNull(c.Start.Owner);
Assert.NotNull(c.End.Owner);
Assert.True(ws2.Nodes.Contains(c.Start.Owner));
Assert.True(ws2.Nodes.Contains(c.End.Owner));
}
//assert that the inputs in the saved json file are the same as those we can gather from the
//graph at runtime - because we don't deserialize these directly we check the json itself.
//Use load vs parse to preserve date time strings.
var jsonReader = new JsonTextReader(new StringReader(json));
jsonReader.DateParseHandling = DateParseHandling.None;
var jObject = JObject.Load(jsonReader);
var jToken = jObject["Inputs"];
var inputs = jToken.ToArray().Select(x => x.ToObject <NodeInputData>()).ToList();
var inputs2 = ws1.Nodes.Where(x => x.IsSetAsInput == true && x.InputData != null).Select(input => input.InputData).ToList();
//inputs2 might come from a WS with non guids, so we need to replace the ids with guids if they exist in the map
foreach (var input in inputs2)
{
if (modelsGuidToIdMap.ContainsKey(input.Id))
{
input.Id = GuidUtility.Create(GuidUtility.UrlNamespace, modelsGuidToIdMap[input.Id]);
}
}
Assert.IsTrue(inputs.SequenceEqual(inputs2));
//assert that the outputs in the saved json file are the same as those we can gather from the
//graph at runtime - because we don't deserialize these directly we check the json itself.
var jTokenOutput = jObject["Outputs"];
var outputs = jTokenOutput.ToArray().Select(x => x.ToObject <NodeOutputData>()).ToList();
var outputs2 = ws1.Nodes.Where(x => x.IsSetAsOutput == true && x.OutputData != null).Select(output => output.OutputData).ToList();
//Outputs2 might come from a WS with non guids, so we need to replace the ids with guids if they exist in the map
foreach (var output in outputs2)
{
if (modelsGuidToIdMap.ContainsKey(output.Id))
{
output.Id = GuidUtility.Create(GuidUtility.UrlNamespace, modelsGuidToIdMap[output.Id]);
}
}
Assert.IsTrue(outputs.SequenceEqual(outputs2));
}
public static bool FromXmlDocument(
XmlDocument xmlDoc, string path, bool isTestMode, bool forceManualExecutionMode, ILogger logger, out WorkspaceInfo workspaceInfo)
{
try
{
string funName = null;
double cx = 0;
double cy = 0;
double zoom = 1.0;
string id = "";
string category = "";
string description = "";
string version = "";
var runType = RunType.Manual;
int runPeriod = RunSettings.DefaultRunPeriod;
bool hasRunWithoutCrash = false;
var topNode = xmlDoc.GetElementsByTagName("Workspace");
// legacy support
if (topNode.Count == 0)
{
topNode = xmlDoc.GetElementsByTagName("dynWorkspace");
}
// load the header
foreach (XmlNode node in topNode)
{
foreach (XmlAttribute att in node.Attributes)
{
if (att.Name.Equals("X"))
{
cx = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("Y"))
{
cy = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("zoom"))
{
zoom = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("Name"))
{
funName = att.Value;
}
else if (att.Name.Equals("ID"))
{
id = att.Value;
}
else if (att.Name.Equals("Category"))
{
category = att.Value;
}
else if (att.Name.Equals("Description"))
{
description = att.Value;
}
else if (att.Name.Equals("HasRunWithoutCrash"))
{
hasRunWithoutCrash = bool.Parse(att.Value);
}
else if (att.Name.Equals("Version"))
{
version = att.Value;
}
else if (att.Name.Equals("RunType"))
{
if (forceManualExecutionMode || !Enum.TryParse(att.Value, false, out runType))
{
runType = RunType.Manual;
}
}
else if (att.Name.Equals("RunPeriod"))
{
runPeriod = Int32.Parse(att.Value);
}
}
}
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName) && funName != "Home")
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
workspaceInfo = new WorkspaceInfo
{
ID = id,
Name = funName,
X = cx,
Y = cy,
Zoom = zoom,
FileName = path,
Category = category,
Description = description,
Version = version,
RunType = runType,
RunPeriod = runPeriod,
HasRunWithoutCrash = hasRunWithoutCrash
};
return(true);
}
catch (Exception ex)
{
logger.Log(Properties.Resources.OpenWorkbenchError);
logger.Log(ex);
Debug.WriteLine(ex.Message + ":" + ex.StackTrace);
//TODO(Steve): Need a better way to handle this kind of thing. -- MAGN-5712
if (isTestMode)
{
throw; // Rethrow for NUnit.
}
workspaceInfo = null;
return(false);
}
}
/// <summary>
/// Return a boolean indicating if successfully deserialized workspace info object from Json file
/// </summary>
/// <param name="jsonDoc">Target Josn</param>
/// <param name="path">Target path</param>
/// <param name="isTestMode">Boolean indicating if Dynamo is running in Test Mode</param>
/// <param name="forceManualExecutionMode">Boolean indicating if forcing manual mode</param>
/// <param name="logger">Dynamo logger</param>
/// <param name="workspaceInfo">Return object</param>
/// <returns>A boolean indicating success</returns>
internal static bool FromJsonDocument(String jsonDoc, string path,/* bool isTestMode,*/
bool forceManualExecutionMode, ILogger logger, out WorkspaceInfo workspaceInfo)
{
var jObject = (JObject)JsonConvert.DeserializeObject(jsonDoc);
try
{
double cx = 0;
double cy = 0;
double zoom = 1.0;
double scaleFactor = 1.0;
string version = "";
var runType = RunType.Manual;
int runPeriod = RunSettings.DefaultRunPeriod;
bool hasRunWithoutCrash = false;
bool isVisibleInDynamoLibrary = true;
JToken value;
string funName = jObject.TryGetValue("Name", out value)? value.ToString(): "";
string id = jObject.TryGetValue("Uuid", out value) ? value.ToString() : "";
string category = jObject.TryGetValue("Category", out value) ? value.ToString() : "";
string description = jObject.TryGetValue("Description", out value) ? value.ToString() : "";
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
//TODO(mjk) we should get rid of this and throw instead or use the isCustomNode flag to determine this
//since non home names are now valid in json format.
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName) && funName != dynamo1HomeWorkspaceNameString)
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
// Parse the following info when graph contains a "View" block
if (jObject.TryGetValue("View", out value))
{
JObject viewObject = value.ToObject <JObject>();
Double.TryParse((viewObject.TryGetValue("X", out value) ? value.ToString(): "0"), out cx);
Double.TryParse((viewObject.TryGetValue("Y", out value) ? value.ToString() : "0"), out cy);
Double.TryParse((viewObject.TryGetValue("Zoom", out value) ? value.ToString() : "1.0"), out zoom);
// Parse the following info when "View" block contains a "Dynamo" block
if (viewObject.TryGetValue("Dynamo", out value))
{
JObject dynamoObject = value.ToObject <JObject>();
Double.TryParse((dynamoObject.TryGetValue("ScaleFactor", out value) ? value.ToString(): "1.0"), out scaleFactor);
Boolean.TryParse((dynamoObject.TryGetValue("HasRunWithoutCrash", out value) ? value.ToString(): "false"), out hasRunWithoutCrash);
Boolean.TryParse((dynamoObject.TryGetValue("IsVisibleInDynamoLibrary", out value) ? value.ToString(): "true"), out isVisibleInDynamoLibrary);
version = dynamoObject.TryGetValue("Version", out value)? value.ToString() : "";
if (forceManualExecutionMode || !Enum.TryParse((dynamoObject.TryGetValue("RunType", out value)? value.ToString(): "false"), false, out runType))
{
runType = RunType.Manual;
}
Int32.TryParse((dynamoObject.TryGetValue("RunPeriod", out value)? value.ToString() : RunSettings.DefaultRunPeriod.ToString()), out runPeriod);
}
}
workspaceInfo = new WorkspaceInfo
{
ID = id,
Name = funName,
X = cx,
Y = cy,
Zoom = zoom,
ScaleFactor = scaleFactor,
FileName = path,
Category = category,
Description = description,
Version = version,
RunType = runType,
RunPeriod = runPeriod,
HasRunWithoutCrash = hasRunWithoutCrash,
IsVisibleInDynamoLibrary = isVisibleInDynamoLibrary
};
return(true);
}
catch (Exception ex)
{
logger.Log(Properties.Resources.OpenWorkbenchError);
logger.Log(ex);
Debug.WriteLine(ex.Message + ":" + ex.StackTrace);
workspaceInfo = null;
return(false);
}
}
/// <summary>
/// Forespør <see cref="Kvittering" /> for <see cref="Forsendelse">Forsendelser</see>, med mulighet til å samtidig
/// <see cref="BekreftAsync">bekrefte</see> på forrige <see cref="Kvittering" /> for å slippe å
/// kjøre eget kall for <see cref="BekreftAsync" />. <see cref="Kvittering">Kvitteringer</see> blir tilgjengeliggjort
/// etterhvert som de er klare i Meldingsformidler. Det er ikke mulig å etterspørre
/// <see cref="Kvittering" /> for en spesifikk forsendelse.
/// </summary>
/// <param name="kvitteringsforespørsel"></param>
/// <param name="forrigeKvittering"></param>
/// <returns></returns>
/// <remarks>
/// <list type="table">
/// <listheader>
/// <description>
/// Dersom det ikke er tilgjengelige <see cref="Kvittering">Kvitteringer</see> skal det ventes følgende
/// tidsintervaller før en ny forespørsel gjøres:
/// </description>
/// </listheader>
/// <item>
/// <term>normal</term><description>Minimum 10 minutter</description>
/// </item>
/// <item>
/// <term>prioritert</term><description>Minimum 1 minutt</description>
/// </item>
/// </list>
/// </remarks>
public async Task<Kvittering> HentKvitteringOgBekreftForrigeAsync(Kvitteringsforespørsel kvitteringsforespørsel, Forretningskvittering forrigeKvittering)
{
if (forrigeKvittering != null)
{
await BekreftAsync(forrigeKvittering).ConfigureAwait(false);
}
var guidUtility = new GuidUtility();
Log.Debug($"Utgående kvitteringsforespørsel, messageId '{guidUtility.MessageId}'.");
var envelopeSettings = new EnvelopeSettings(kvitteringsforespørsel, Databehandler, guidUtility);
var kvitteringsforespørselEnvelope = new KvitteringsforespørselEnvelope(envelopeSettings);
ValidateEnvelopeAndThrowIfInvalid(kvitteringsforespørselEnvelope, kvitteringsforespørselEnvelope.GetType().Name);
var receipt = await RequestHelper.GetReceipt(kvitteringsforespørselEnvelope).ConfigureAwait(false);
var transportReceiptXml = XmlUtility.TilXmlDokument(receipt.Rådata);
if (receipt is TomKøKvittering)
{
Log.Debug($"{receipt}");
SecurityValidationOfEmptyQueueReceipt(transportReceiptXml, kvitteringsforespørselEnvelope.Xml());
}
else if (receipt is Forretningskvittering)
{
Log.Debug($"{receipt}");
SecurityValidationOfMessageReceipt(transportReceiptXml, kvitteringsforespørselEnvelope);
}
return receipt;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
//if we can't find this type - try to look in our load from assemblies,
//but only during testing - this is required during testing because some dlls are loaded
//using Assembly.LoadFrom using the assemblyHelper - which loads dlls into loadFrom context -
//dlls loaded with LoadFrom context cannot be found using Type.GetType() - this should
//not be an issue during normal dynamo use but if it is we can enable this code.
if (type == null && this.isTestMode == true)
{
List <Assembly> resultList;
var typeName = obj["$type"].Value <string>().Split(',').FirstOrDefault();
//this assemblyName does not usually contain version information...
var assemblyName = obj["$type"].Value <string>().Split(',').Skip(1).FirstOrDefault().Trim();
if (assemblyName != null)
{
if (this.loadedAssemblies.TryGetValue(assemblyName, out resultList))
{
var matchingTypes = resultList.Select(x => x.GetType(typeName)).ToList();
type = matchingTypes.FirstOrDefault();
}
}
}
// If the id is not a guid, makes a guid based on the id of the node
var guid = GuidUtility.tryParseOrCreateGuid(obj["Id"].Value <string>());
var replication = obj["Replication"].Value <string>();
var inPorts = obj["Inputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["Outputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
string assemblyLocation = objectType.Assembly.Location;
bool remapPorts = true;
if (type == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
CustomNodeDefinition def = null;
CustomNodeInfo info = null;
bool isUnresolved = !manager.TryGetCustomNodeData(functionId, null, false, out def, out info);
Function function = manager.CreateCustomNodeInstance(functionId, null, false, def, info);
node = function;
if (isUnresolved)
{
function.UpdatePortsForUnresolved(inPorts, outPorts);
}
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
CodeBlockNodeModel codeBlockNode = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
node = codeBlockNode;
// If the code block node is in an error state read the extra port data
// and initialize the input and output ports
if (node.IsInErrorState)
{
List <string> inPortNames = new List <string>();
var inputs = obj["Inputs"];
foreach (var input in inputs)
{
inPortNames.Add(input["Name"].ToString());
}
// NOTE: This could be done in a simpler way, but is being implemented
// in this manner to allow for possible future port line number
// information being available in the file
List <int> outPortLineIndexes = new List <int>();
var outputs = obj["Outputs"];
int outputLineIndex = 0;
foreach (var output in outputs)
{
outPortLineIndexes.Add(outputLineIndex++);
}
codeBlockNode.SetErrorStatePortData(inPortNames, outPortLineIndexes);
}
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionSignature"].Value <string>();
var functionDescriptor = libraryServices.GetFunctionDescriptor(mangledName);
if (functionDescriptor == null)
{
node = CreateDummyNode(obj, assemblyLocation, inPorts, outPorts);
}
else
{
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(functionDescriptor);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(functionDescriptor);
}
}
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionSignature"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
}
else if (type.ToString() == "CoreNodeModels.Formula")
{
node = (NodeModel)obj.ToObject(type);
}
else
{
node = (NodeModel)obj.ToObject(type);
// We don't need to remap ports for any nodes with json constructors which pass ports
remapPorts = false;
}
if (remapPorts)
{
RemapPorts(node, inPorts, outPorts, resolver);
}
// Cannot set Lacing directly as property is protected
node.UpdateValue(new UpdateValueParams("ArgumentLacing", replication));
node.GUID = guid;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
private Dictionary <string, List <string> > GetPartnermerchantIds(Merchant merchant)
{
Dictionary <string, List <string> > partnerIds = new Dictionary <string, List <string> >();
Log.Info($"[{nameof(GetPartnermerchantIds)}] Processing merchant {merchant.Name}");
foreach (var payment in merchant.Payments)
{
if (payment.Processor == PaymentProcessor.MasterCard)
{
string masterCardMid = ProcessMasterCardMid(merchant.Name, payment);
if (masterCardMid != null)
{
if (!partnerIds.ContainsKey(PaymentProcessor.MasterCard.ToString()))
{
partnerIds[PaymentProcessor.MasterCard.ToString()] =
new List <string> {
masterCardMid
}
}
;
else
{
partnerIds[PaymentProcessor.MasterCard.ToString()].Add(masterCardMid);
}
Log.Info($"Added MasterCardMID {masterCardMid} of PaymentId {payment.Id} to PartnerMids collection for {merchant.Name}");
}
}
else if (payment.Processor == PaymentProcessor.Visa)
{
string visaMid = ProcessVisaMid(merchant.Name, payment);
if (!string.IsNullOrWhiteSpace(visaMid))
{
if (!partnerIds.ContainsKey(PaymentProcessor.Visa.ToString()))
{
partnerIds[PaymentProcessor.Visa.ToString()] =
new List <string> {
visaMid
}
}
;
else
{
partnerIds[PaymentProcessor.Visa.ToString()].Add(visaMid);
}
Log.Info($"Added VisaMID {visaMid} of PaymentId {payment.Id} to PartnerMids collection for {merchant.Name}");
}
}
else if (payment.Processor == PaymentProcessor.Amex)
{
string amexSeNumber = payment.PaymentMids.ContainsKey(MerchantConstants.AmexSENumber) ? payment.PaymentMids[MerchantConstants.AmexSENumber] : null;
if (!string.IsNullOrWhiteSpace(amexSeNumber))
{
// Upload it to commerce for further processing
string detailRecord = new OfferRegistrationDetail()
{
ActionCode = OfferRegistrationActionCodeType.Add, // Need to update if already added Merchant
MerchantName = merchant.Name,
MerchantNumber = amexSeNumber,
MerchantEndDate = DateTime.UtcNow.AddYears(10),
MerchantId = merchant.Id,
OfferName = "Earn Offer",
MerchantStartDate = DateTime.UtcNow
}.BuildFileDetailRecord();
string blobName = "ToBeProcessed/" + amexSeNumber + "-" + GuidUtility.GenerateShortGuid() + ".txt";
byte[] contentBytes = Encoding.ASCII.GetBytes(detailRecord);
MemoryStream ms = new MemoryStream(contentBytes);
ms.Position = 0;
Task task = MerchantRegistrationAzureBlob.UploadBlobFromStreamAsync("amex-offer-registrationrecords", blobName, ms);
// commerce registration
string formattedSeNumber = $"{amexSeNumber};1";
if (!partnerIds.ContainsKey(PaymentProcessor.Amex.ToString()))
{
partnerIds[PaymentProcessor.Amex.ToString()] = new List <string> {
formattedSeNumber
}
}
;
else
{
partnerIds[PaymentProcessor.Amex.ToString()].Add(formattedSeNumber);
}
Task.WaitAny(task);
Log.Info($"Added Amex SEnumber {formattedSeNumber} of PaymentId {payment.Id} to PartnerMids collection for {merchant.Name}");
}
}
}
return(partnerIds);
}
public static Guid Create(byte[] bytes) => new Guid(GuidUtility.CopyWithEndianSwap(bytes));
public MockSubscriptionInfo(string uri, Guid namespaceId)
{
RequestUuid = GuidUtility.Create(namespaceId, uri);
IncludeObjectData = false;
Context = new MockGraphContext(new EtpUri(uri));
}
/// <summary>
/// 获取一个GUID
/// </summary>
/// <returns></returns>
protected virtual string GetGuid()
{
return(GuidUtility.GetGuid());
}
public static WorkspaceHeader FromPath(DynamoModel dynamoModel, string path)
{
try
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string funName = null;
double cx = 0;
double cy = 0;
double zoom = 1.0;
string id = "";
var topNode = xmlDoc.GetElementsByTagName("Workspace");
// legacy support
if (topNode.Count == 0)
{
topNode = xmlDoc.GetElementsByTagName("dynWorkspace");
}
// load the header
foreach (XmlNode node in topNode)
{
foreach (XmlAttribute att in node.Attributes)
{
if (att.Name.Equals("X"))
{
cx = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("Y"))
{
cy = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("zoom"))
{
zoom = double.Parse(att.Value, CultureInfo.InvariantCulture);
}
else if (att.Name.Equals("Name"))
{
funName = att.Value;
}
else if (att.Name.Equals("ID"))
{
id = att.Value;
}
}
}
// we have a dyf and it lacks an ID field, we need to assign it
// a deterministic guid based on its name. By doing it deterministically,
// files remain compatible
if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName) && funName != "Home")
{
id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString();
}
return(new WorkspaceHeader()
{
ID = id, Name = funName, X = cx, Y = cy, Zoom = zoom, FileName = path
});
}
catch (Exception ex)
{
dynamoModel.Logger.Log("There was an error opening the workbench.");
dynamoModel.Logger.Log(ex);
Debug.WriteLine(ex.Message + ":" + ex.StackTrace);
if (DynamoModel.IsTestMode)
{
throw ex; // Rethrow for NUnit.
}
return(null);
}
}
public HashedStringGuidSource(Guid namespaceId, string @string)
{
_string = @string;
_guid = GuidUtility.Create(namespaceId, @string ?? string.Empty);
}
/// <summary>
/// Copy test file to specified folder while
/// maintaining original directory structure
/// and assigning file path as workspace name.
/// These are .dyn or .dyf files.
/// </summary>
/// <param name="filePath">original test file path</param>
/// <param name="jo">test json object</param>
private static void SaveJsonTempWithFolderStructure(string filePath, JObject jo, DynamoModel currentDynamoModel)
{
// Get all folder structure following "\\test"
var expectedStructure = filePath.Remove(0, SerializationTests.TestDirectory.Length);
var newWSName = expectedStructure.Replace("\\", "/");
var extension = Path.GetExtension(filePath);
// Update WS name to original test file path
jo["Name"] = newWSName;
if (extension == ".dyf")
{
// If .dyf file use the existing Uuid
var customNodeWS = currentDynamoModel.CurrentWorkspace as CustomNodeWorkspaceModel;
if (customNodeWS != null)
{
jo["Uuid"] = customNodeWS.CustomNodeId;
}
}
else
{
// If .dyn file update Uuid to be unique based on new WS name
var nameBasedGuid = GuidUtility.Create(currentDynamoModel.CurrentWorkspace.Guid, newWSName);
jo["Uuid"] = nameBasedGuid;
}
// Current test fileName
var fileName = Path.GetFileName(filePath);
// Get temp folder path
var tempPath = Path.GetTempPath();
var jsonFolder = Path.Combine(tempPath, jsonStructuredFolderName);
jsonFolder += Path.GetDirectoryName(expectedStructure);
if (!System.IO.Directory.Exists(jsonFolder))
{
System.IO.Directory.CreateDirectory(jsonFolder);
}
// TODO add check to make sure a .dyn or .dyf with the same name does not exist
// Combine directory with test file name
var jsonPath = jsonFolder + "\\" + fileName;
if (File.Exists(jsonPath))
{
File.Delete(jsonPath);
}
File.WriteAllText(jsonPath, jo.ToString());
// Write DesignScript file
string dsFileName = Path.GetFileNameWithoutExtension(fileName);
// Determine if .dyn or .dyf
// If .dyn and .dyf share common file name .ds and .data files is collide
// To avoid this append _dyf to .data and .ds files for all .dyf files
if (extension == ".dyf")
{
dsFileName += "_dyf";
}
string dsPath = jsonFolder + "\\" + dsFileName;
serializationTestUtils.ConvertCurrentWorkspaceToDesignScriptAndSave(dsPath, currentDynamoModel);
}
/// <summary>
/// Process Authentication Request
/// </summary>
/// <returns></returns>
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
// get siteminder headers
_logger.LogDebug("Parsing the HTTP headers for SiteMinder authentication credential");
SiteMinderAuthOptions options = new SiteMinderAuthOptions();
bool isDeveloperLogin = false;
bool isBCSCDeveloperLogin = false;
try
{
ClaimsPrincipal principal;
HttpContext context = Request.HttpContext;
IDynamicsClient _dynamicsClient = (IDynamicsClient)context.RequestServices.GetService(typeof(IDynamicsClient));
IHostingEnvironment hostingEnv = (IHostingEnvironment)context.RequestServices.GetService(typeof(IHostingEnvironment));
UserSettings userSettings = new UserSettings();
string userId = null;
string devCompanyId = null;
string siteMinderGuid = "";
string siteMinderBusinessGuid = "";
string siteMinderUserType = "";
// **************************************************
// If this is an Error or Authentiation API - Ignore
// **************************************************
string url = context.Request.GetDisplayUrl().ToLower();
if (url.Contains(".js"))
{
return(AuthenticateResult.NoResult());
}
// **************************************************
// Check if we have a Dev Environment Cookie
// **************************************************
if (!hostingEnv.IsProduction())
{
// check for a fake BCeID login in dev mode
string temp = context.Request.Cookies[options.DevAuthenticationTokenKey];
if (string.IsNullOrEmpty(temp)) // could be an automated test user.
{
temp = context.Request.Headers["DEV-USER"];
}
if (!string.IsNullOrEmpty(temp))
{
if (temp.Contains("::"))
{
var temp2 = temp.Split("::");
userId = temp2[0];
if (temp2.Length >= 2)
{
devCompanyId = temp2[1];
}
else
{
devCompanyId = temp2[0];
}
}
else
{
userId = temp;
devCompanyId = temp;
}
isDeveloperLogin = true;
_logger.LogDebug("Got user from dev cookie = " + userId + ", company = " + devCompanyId);
}
else
{
// same set of tests for a BC Services Card dev login
temp = context.Request.Cookies[options.DevBCSCAuthenticationTokenKey];
if (string.IsNullOrEmpty(temp)) // could be an automated test user.
{
temp = context.Request.Headers["DEV-BCSC-USER"];
}
if (!string.IsNullOrEmpty(temp))
{
userId = temp;
isBCSCDeveloperLogin = true;
_logger.LogDebug("Got user from dev cookie = " + userId);
}
}
}
// **************************************************
// Check if the user session is already created
// **************************************************
try
{
_logger.LogInformation("Checking user session");
userSettings = UserSettings.ReadUserSettings(context);
_logger.LogDebug("UserSettings found: " + userSettings.GetJson());
}
catch
{
//do nothing
_logger.LogDebug("No UserSettings found");
}
// is user authenticated - if so we're done
if ((userSettings.UserAuthenticated && string.IsNullOrEmpty(userId)) ||
(userSettings.UserAuthenticated && !string.IsNullOrEmpty(userId) &&
!string.IsNullOrEmpty(userSettings.UserId) && userSettings.UserId == userId))
{
_logger.LogDebug("User already authenticated with active session: " + userSettings.UserId);
principal = userSettings.AuthenticatedUser.ToClaimsPrincipal(options.Scheme, userSettings.UserType);
return(AuthenticateResult.Success(new AuthenticationTicket(principal, null, Options.Scheme)));
}
string smgov_userdisplayname = context.Request.Headers["smgov_userdisplayname"];
if (!string.IsNullOrEmpty(smgov_userdisplayname))
{
userSettings.UserDisplayName = smgov_userdisplayname;
}
string smgov_businesslegalname = context.Request.Headers["smgov_businesslegalname"];
if (!string.IsNullOrEmpty(smgov_businesslegalname))
{
userSettings.BusinessLegalName = smgov_businesslegalname;
}
// **************************************************
// Authenticate based on SiteMinder Headers
// **************************************************
_logger.LogDebug("Parsing the HTTP headers for SiteMinder authentication credential");
// At this point userID would only be set if we are logging in through as a DEV user
if (string.IsNullOrEmpty(userId))
{
_logger.LogDebug("Getting user data from headers");
userId = context.Request.Headers[options.SiteMinderUserNameKey];
if (string.IsNullOrEmpty(userId))
{
userId = context.Request.Headers[options.SiteMinderUniversalIdKey];
}
siteMinderGuid = context.Request.Headers[options.SiteMinderUserGuidKey];
siteMinderBusinessGuid = context.Request.Headers[options.SiteMinderBusinessGuidKey];
siteMinderUserType = context.Request.Headers[options.SiteMinderUserTypeKey];
// **************************************************
// Validate credentials
// **************************************************
if (string.IsNullOrEmpty(userId))
{
_logger.LogDebug(options.MissingSiteMinderUserIdError);
return(AuthenticateResult.Fail(options.MissingSiteMinderGuidError));
}
if (string.IsNullOrEmpty(siteMinderGuid))
{
_logger.LogDebug(options.MissingSiteMinderGuidError);
return(AuthenticateResult.Fail(options.MissingSiteMinderGuidError));
}
if (string.IsNullOrEmpty(siteMinderUserType))
{
_logger.LogDebug(options.MissingSiteMinderUserTypeError);
return(AuthenticateResult.Fail(options.MissingSiteMinderUserTypeError));
}
}
else // DEV user, setup a fake session and SiteMinder headers.
{
if (isDeveloperLogin)
{
_logger.LogError("Generating a Development user");
userSettings.BusinessLegalName = devCompanyId + " TestBusiness";
userSettings.UserDisplayName = userId + " TestUser";
siteMinderGuid = GuidUtility.CreateIdForDynamics("contact", userSettings.UserDisplayName).ToString();
siteMinderBusinessGuid = GuidUtility.CreateIdForDynamics("account", userSettings.BusinessLegalName).ToString();
siteMinderUserType = "Business";
}
else if (isBCSCDeveloperLogin)
{
_logger.LogError("Generating a Development BC Services user");
userSettings.BusinessLegalName = null;
userSettings.UserDisplayName = userId + " Associate";
siteMinderGuid = GuidUtility.CreateIdForDynamics("bcsc", userSettings.UserDisplayName).ToString();
siteMinderBusinessGuid = null;
siteMinderUserType = "VerifiedIndividual";
}
}
// Previously the code would do a database lookup here. However there is no backing database for the users table now,
// so we just do a Dynamics lookup on the siteMinderGuid.
_logger.LogDebug("Loading user external id = " + siteMinderGuid);
userSettings.AuthenticatedUser = await _dynamicsClient.LoadUser(siteMinderGuid, context.Request.Headers, _logger);
_logger.LogDebug("After getting authenticated user = "******" (" + userId + ")");
return(AuthenticateResult.Fail(options.InactivegDbUserIdError));
}
if (userSettings.AuthenticatedUser != null && !String.IsNullOrEmpty(siteMinderUserType))
{
userSettings.AuthenticatedUser.UserType = siteMinderUserType;
}
userSettings.UserType = siteMinderUserType;
// This line gets the various claims for the current user.
ClaimsPrincipal userPrincipal = userSettings.AuthenticatedUser.ToClaimsPrincipal(options.Scheme, userSettings.UserType);
// **************************************************
// Create authenticated user
// **************************************************
_logger.LogDebug("Authentication successful: " + userId);
_logger.LogDebug("Setting identity and creating session for: " + userId);
// create session info for the current user
userSettings.UserId = userId;
userSettings.UserAuthenticated = true;
userSettings.IsNewUserRegistration = (userSettings.AuthenticatedUser == null);
// set other session info
userSettings.SiteMinderGuid = siteMinderGuid;
userSettings.SiteMinderBusinessGuid = siteMinderBusinessGuid;
_logger.LogDebug("Before getting contact and account ids = " + userSettings.GetJson());
if (userSettings.AuthenticatedUser != null)
{
userSettings.ContactId = userSettings.AuthenticatedUser.ContactId.ToString();
if (siteMinderBusinessGuid != null) // BCeID user
{
var account = await _dynamicsClient.GetAccountBySiteminderBusinessGuid(siteMinderBusinessGuid);
if (account != null && account.Accountid != null)
{
userSettings.AccountId = account.Accountid;
userSettings.AuthenticatedUser.AccountId = Guid.Parse(account.Accountid);
}
}
}
if (!hostingEnv.IsProduction() && (isDeveloperLogin || isBCSCDeveloperLogin))
{
_logger.LogError("DEV MODE Setting identity and creating session for: " + userId);
if (isDeveloperLogin)
{
userSettings.BusinessLegalName = devCompanyId + " TestBusiness";
userSettings.UserDisplayName = userId + " TestUser";
// add generated guids
userSettings.SiteMinderBusinessGuid = GuidUtility.CreateIdForDynamics("account", userSettings.BusinessLegalName).ToString();
userSettings.SiteMinderGuid = GuidUtility.CreateIdForDynamics("contact", userSettings.UserDisplayName).ToString();
}
else if (isBCSCDeveloperLogin)
{
userSettings.BusinessLegalName = null;
userSettings.UserDisplayName = userId + " Associate";
// add generated guids
userSettings.SiteMinderBusinessGuid = null;
userSettings.SiteMinderGuid = GuidUtility.CreateIdForDynamics("bcsc", userSettings.UserDisplayName).ToString();
}
if (userSettings.IsNewUserRegistration)
{
if (isDeveloperLogin)
{
// add generated guids
userSettings.AccountId = userSettings.SiteMinderBusinessGuid;
userSettings.ContactId = userSettings.SiteMinderGuid;
}
else if (isBCSCDeveloperLogin)
{
// set to null for now
userSettings.AccountId = null;
userSettings.ContactId = null;
}
_logger.LogDebug("New user registration:" + userSettings.UserDisplayName);
_logger.LogDebug("userSettings.SiteMinderBusinessGuid:" + userSettings.SiteMinderBusinessGuid);
_logger.LogDebug("userSettings.SiteMinderGuid:" + userSettings.SiteMinderGuid);
_logger.LogDebug("userSettings.AccountId:" + userSettings.AccountId);
_logger.LogDebug("userSettings.ContactId:" + userSettings.ContactId);
}
// Set account ID from authenticated user
else if (userSettings.AuthenticatedUser != null)
{
// populate the business GUID.
if (string.IsNullOrEmpty(userSettings.AccountId))
{
userSettings.AccountId = userSettings.AuthenticatedUser.AccountId.ToString();
}
if (string.IsNullOrEmpty(userSettings.ContactId))
{
userSettings.ContactId = userSettings.AuthenticatedUser.ContactId.ToString();
}
_logger.LogDebug("Returning user:"******"userSettings.AccountId:" + userSettings.AccountId);
_logger.LogDebug("userSettings.ContactId:" + userSettings.ContactId);
}
}
// add the worker settings if it is a new user.
if (userSettings.IsNewUserRegistration && userSettings.NewWorker == null)
{
userSettings.NewWorker = new ViewModels.Worker();
userSettings.NewWorker.CopyHeaderValues(context.Request.Headers);
}
// add the worker settings if it is a new user.
if (userSettings.IsNewUserRegistration && userSettings.NewContact == null)
{
userSettings.NewContact = new ViewModels.Contact();
userSettings.NewContact.CopyHeaderValues(context.Request.Headers);
}
// **************************************************
// Update user settings
// **************************************************
UserSettings.SaveUserSettings(userSettings, context);
// done!
principal = userPrincipal;
return(AuthenticateResult.Success(new AuthenticationTicket(principal, null, Options.Scheme)));
}
catch (Exception exception)
{
_logger.LogError(exception.Message);
Console.WriteLine(exception);
throw;
}
}
public IEnumerable <ID> LoadAutoToken(AutoToken token)
{
using (new SecurityDisabler())
{
if (TokenCollections.ContainsKey(token.CollectionName))
{
TokenCollections[token.CollectionName].AddOrUpdateToken(token.Token, token);
}
else
{
TokenCollections[token.CollectionName] = new AutoTokenCollection(token);
TokenCollections[token.CollectionName].AddOrUpdateToken(token.Token, token);
}
var db = Factory.GetDatabase("core", false);
if (db == null)
{
yield break;
}
TokenButton tb = token.TokenButton();
foreach (Item parent in db.DataManager.DataEngine
.GetItem(new ID(Constants.Core.RteParent), LanguageManager.DefaultLanguage, Sitecore.Data.Version.Latest).Axes
.GetDescendants().Where(x =>
x.Name == "Toolbar 1" && x.TemplateID.ToString() == "{0E0DA701-BC94-4855-A0C3-92063E64BA1F}"))
{
ID buttonId = GuidUtility.GetId("tokenmanager", $"{token.CollectionName}{token.Token}{parent.ID}");
Item button = db.DataManager.DataEngine.GetItem(buttonId, LanguageManager.DefaultLanguage, Sitecore.Data.Version.Latest);
if (tb != null)
{
yield return(buttonId);
if (button != null)
{
if (
button["Click"] == $"TokenSelector{Regex.Replace(token.CollectionName, "[^A-Za-z0-9_]", "")}{Regex.Replace(token.Token, "[^A-Za-z0-9_]", "")}" &&
button[FieldIDs.DisplayName] == tb.Name &&
button["Shortcut"] == $"?Category={token.CollectionName}&Token={token.Token}" &&
button[FieldIDs.Sortorder] == tb.SortOrder.ToString() &&
button[FieldIDs.Icon] == (string.IsNullOrWhiteSpace(tb.Icon) ? token.TokenIcon : tb.Icon))
{
continue;
}
}
else
{
button = db.DataManager.DataEngine.CreateItem(tb.Name, parent, new ID(Constants.Core.ButtonTemplate), buttonId);
}
button.Editing.BeginEdit();
button["Click"] = $"TokenSelector{Regex.Replace(token.CollectionName, "[^A-Za-z0-9_]", "")}{Regex.Replace(token.Token, "[^A-Za-z0-9_]", "")}";
button[FieldIDs.DisplayName] = tb.Name;
button["Shortcut"] = $"?Category={token.CollectionName}&Token={token.Token}";
button[FieldIDs.Sortorder] = tb.SortOrder.ToString();
button[FieldIDs.Icon] = string.IsNullOrWhiteSpace(tb.Icon) ? token.TokenIcon : tb.Icon;
button.Editing.EndEdit(false, true);
button.Database.Caches.ItemCache.RemoveItem(buttonId);
button.Database.Caches.DataCache.RemoveItemInformation(buttonId);
}
else
{
button?.Recycle();
}
}
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
NodeModel node = null;
var obj = JObject.Load(reader);
var type = Type.GetType(obj["$type"].Value <string>());
//if the id is not a guid, makes a guid based on the id of the node
var guid = GuidUtility.tryParseOrCreateGuid(obj["Id"].Value <string>());
var inPorts = obj["Inputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var outPorts = obj["Outputs"].ToArray().Select(t => t.ToObject <PortModel>()).ToArray();
var resolver = (IdReferenceResolver)serializer.ReferenceResolver;
if (type == typeof(Function))
{
var functionId = Guid.Parse(obj["FunctionUuid"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type == typeof(CodeBlockNodeModel))
{
var code = obj["Code"].Value <string>();
node = new CodeBlockNodeModel(code, guid, 0.0, 0.0, libraryServices, ElementResolver);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (typeof(DSFunctionBase).IsAssignableFrom(type))
{
var mangledName = obj["FunctionSignature"].Value <string>();
var description = libraryServices.GetFunctionDescriptor(mangledName);
if (type == typeof(DSVarArgFunction))
{
node = new DSVarArgFunction(description);
// The node syncs with the function definition.
// Then we need to make the inport count correct
var varg = (DSVarArgFunction)node;
varg.VarInputController.SetNumInputs(inPorts.Count());
}
else if (type == typeof(DSFunction))
{
node = new DSFunction(description);
}
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type == typeof(DSVarArgFunction))
{
var functionId = Guid.Parse(obj["FunctionUuid"].Value <string>());
node = manager.CreateCustomNodeInstance(functionId);
RemapPorts(node, inPorts, outPorts, resolver);
}
else if (type.ToString() == "CoreNodeModels.Formula")
{
node = (NodeModel)obj.ToObject(type);
RemapPorts(node, inPorts, outPorts, resolver);
}
else
{
node = (NodeModel)obj.ToObject(type);
}
node.GUID = guid;
// Add references to the node and the ports to the reference resolver,
// so that they are available for entities which are deserialized later.
serializer.ReferenceResolver.AddReference(serializer.Context, node.GUID.ToString(), node);
foreach (var p in node.InPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
foreach (var p in node.OutPorts)
{
serializer.ReferenceResolver.AddReference(serializer.Context, p.GUID.ToString(), p);
}
return(node);
}
public void ValidateTransportReceipt(GuidUtility guidUtility)
{
ValidateHeaderSignature();
ValidateDigest(guidUtility);
}
protected override void LoadNode(XmlNode nodeElement)
{
List <XmlNode> childNodes = nodeElement.ChildNodes.Cast <XmlNode>().ToList();
XmlNode nameNode = childNodes.LastOrDefault(subNode => subNode.Name.Equals("Name"));
if (nameNode != null && nameNode.Attributes != null)
{
NickName = nameNode.Attributes[0].Value;
}
XmlNode idNode = childNodes.LastOrDefault(subNode => subNode.Name.Equals("ID"));
if (idNode != null && idNode.Attributes != null)
{
string id = idNode.Attributes[0].Value;
Guid funcId;
if (!Guid.TryParse(id, out funcId) && nodeElement.Attributes != null)
{
funcId = GuidUtility.Create(GuidUtility.UrlNamespace, nodeElement.Attributes["nickname"].Value);
}
if (!VerifyFuncId(ref funcId))
{
LoadProxyCustomNode(funcId);
}
Definition = Workspace.DynamoModel.CustomNodeManager.GetFunctionDefinition(funcId);
if (Definition.IsProxy)
{
Error("Cannot load custom node");
}
}
foreach (XmlNode subNode in childNodes)
{
if (subNode.Name.Equals("Outputs"))
{
var data =
subNode.ChildNodes.Cast <XmlNode>()
.Select(
(outputNode, i) =>
new
{
data = new PortData(outputNode.Attributes[0].Value, "Output #" + (i + 1)),
idx = i
});
foreach (var dataAndIdx in data)
{
if (OutPortData.Count > dataAndIdx.idx)
{
OutPortData[dataAndIdx.idx] = dataAndIdx.data;
}
else
{
OutPortData.Add(dataAndIdx.data);
}
}
}
else if (subNode.Name.Equals("Inputs"))
{
var data =
subNode.ChildNodes.Cast <XmlNode>()
.Select(
(inputNode, i) =>
new
{
data = new PortData(inputNode.Attributes[0].Value, "Input #" + (i + 1)),
idx = i
});
foreach (var dataAndIdx in data)
{
if (InPortData.Count > dataAndIdx.idx)
{
InPortData[dataAndIdx.idx] = dataAndIdx.data;
}
else
{
InPortData.Add(dataAndIdx.data);
}
}
}
#region Legacy output support
else if (subNode.Name.Equals("Output"))
{
var data = new PortData(subNode.Attributes[0].Value, "function output");
if (OutPortData.Any())
{
OutPortData[0] = data;
}
else
{
OutPortData.Add(data);
}
}
#endregion
}
if (!IsInSyncWithDefinition())
{
ResyncWithDefinition();
}
else
{
RegisterAllPorts();
}
//argument lacing on functions should be set to disabled
//by default in the constructor, but for any workflow saved
//before this was the case, we need to ensure it here.
ArgumentLacing = LacingStrategy.Disabled;
//if (Definition != null)
// ResyncWithDefinition();
}
private async Task UpsertSellableItem(SellableItem item, CommercePipelineExecutionContext context)
{
if (string.IsNullOrEmpty(item.ProductId))
{
item.ProductId = item.Id.SimplifyEntityName().ProposeValidId();
}
if (string.IsNullOrEmpty(item.FriendlyId))
{
item.FriendlyId = item.Id.SimplifyEntityName();
}
if (string.IsNullOrEmpty(item.SitecoreId))
{
item.SitecoreId = GuidUtility.GetDeterministicGuidString(item.Id);
}
var entity = await _findEntityPipeline.Run(new FindEntityArgument(typeof(SellableItem), item.Id), context).ConfigureAwait(false);
if (entity == null)
{
await _persistEntityPipeline.Run(new PersistEntityArgument(item), context).ConfigureAwait(false);
return;
}
if (!(entity is SellableItem))
{
return;
}
var existingSellableItem = entity as SellableItem;
// Try to merge the items.
existingSellableItem.Name = item.Name;
foreach (var policy in item.EntityPolicies)
{
if (existingSellableItem.HasPolicy(policy.GetType()))
{
existingSellableItem.RemovePolicy(policy.GetType());
}
existingSellableItem.SetPolicy(policy);
}
if (item.HasComponent <ItemVariationsComponent>())
{
var variations = existingSellableItem.GetComponent <ItemVariationsComponent>();
foreach (var variation in item.GetComponent <ItemVariationsComponent>().ChildComponents.OfType <ItemVariationComponent>())
{
var existingVariation = existingSellableItem.GetVariation(variation.Id);
if (existingVariation != null)
{
existingVariation.Name = variation.Name;
foreach (var policy in variation.Policies)
{
if (existingVariation.Policies.Any(x => x.GetType() == policy.GetType()))
{
existingVariation.RemovePolicy(policy.GetType());
}
existingVariation.SetPolicy(policy);
}
}
else
{
variations.ChildComponents.Add(variation);
}
}
}
await _persistEntityPipeline.Run(new PersistEntityArgument(existingSellableItem), context).ConfigureAwait(false);
}
protected override void DeserializeCore(XmlElement element, SaveContext context)
{
base.DeserializeCore(element, context); //Base implementation must be called
if (context == SaveContext.Undo)
{
var helper = new XmlElementHelper(element);
NickName = helper.ReadString("functionName");
Guid funcId;
if (!Guid.TryParse(helper.ReadString("functionId"), out funcId))
{
funcId = GuidUtility.Create(GuidUtility.UrlNamespace, NickName);
}
if (!VerifyFuncId(ref funcId))
{
LoadProxyCustomNode(funcId);
return;
}
Definition = Workspace.DynamoModel.CustomNodeManager.GetFunctionDefinition(funcId);
XmlNodeList inNodes = element.SelectNodes("functionInput");
XmlNodeList outNodes = element.SelectNodes("functionOutput");
var inData =
inNodes.Cast <XmlNode>()
.Select(
(inputNode, i) =>
new
{
data = new PortData(inputNode.Attributes[0].Value, "Input #" + (i + 1)),
idx = i
});
foreach (var dataAndIdx in inData)
{
if (InPortData.Count > dataAndIdx.idx)
{
InPortData[dataAndIdx.idx] = dataAndIdx.data;
}
else
{
InPortData.Add(dataAndIdx.data);
}
}
var outData =
outNodes.Cast <XmlNode>()
.Select(
(outputNode, i) =>
new
{
data = new PortData(outputNode.Attributes[0].Value, "Output #" + (i + 1)),
idx = i
});
foreach (var dataAndIdx in outData)
{
if (OutPortData.Count > dataAndIdx.idx)
{
OutPortData[dataAndIdx.idx] = dataAndIdx.data;
}
else
{
OutPortData.Add(dataAndIdx.data);
}
}
//Added it the same way as LoadNode. But unsure of when 'Output' ChildNodes will
//be added to element. As of now I dont think it is added during serialize
#region Legacy output support
foreach (var portData in
from XmlNode subNode in element.ChildNodes
where subNode.Name.Equals("Output")
select new PortData(subNode.Attributes[0].Value, "function output"))
{
if (OutPortData.Any())
{
OutPortData[0] = portData;
}
else
{
OutPortData.Add(portData);
}
}
#endregion
RegisterAllPorts();
Description = helper.ReadString("functionDesc");
}
}
/// <summary>
/// 用户，组织创建权限
/// </summary>
/// <param name="userId"></param>
/// <param name="orgId"></param>
/// <returns></returns>
public OperationResult CreateAdminAuthor(string userId, string orgId)
{
OperationResult result = new OperationResult();
//用户对于的角色
UserRoleRelationDAO userRoleRelation = new UserRoleRelationDAO()
{
MItemID = GuidUtility.GetGuid(),
MUserID = userId,
MOrgID = orgId,
//管理员
MRoleID = "10000"
};
//获取用户组模型
UserGroupRelationDAO userGroupRelation = new UserGroupRelationDAO()
{
MItemID = GuidUtility.GetGuid(),
MUserID = userId,
MOrgID = orgId,
MGroupID = "10000"
};
GroupRoleRealtionDAO groupRoleRealtion = new GroupRoleRealtionDAO()
{
MGroupID = "10000",
MRoleID = "10000",
MItemID = GuidUtility.GetGuid(),
};
//获取角色，权限关系模型
List <RolePermisionRelationDAO> rolePermisionRelations = GetRolePermisionRelations(orgId, "10000", "11111");
//获取角色，权限关系模型
List <GroupPermissionRelationDAO> groupPermisionRelations = GetGroupPermisionRelations(orgId, "10000", "11111");
try
{
result.Success = _authorRepository.AddAuthor(userGroupRelation, userRoleRelation, rolePermisionRelations, groupPermisionRelations);
//如果成功，返回一个权限创建成功队列
if (result.Success)
{
AuthorCreatedEvent @event = new AuthorCreatedEvent()
{
OrgId = orgId, UserId = userId
};
_eventBus.PublishAsync <AuthorCreatedEvent>(@event);
}
else
{
OrganizationRollbackEvent @event = new OrganizationRollbackEvent()
{
OrgId = orgId
};
_eventBus.PublishAsync <OrganizationRollbackEvent>(@event);
}
}
catch (Exception ex)
{
//如果创建失败，发送一个组织回滚事件
OrganizationRollbackEvent @event = new OrganizationRollbackEvent()
{
OrgId = orgId
};
_eventBus.PublishAsync <OrganizationRollbackEvent>(@event);
}
return(result);
}
private async Task <AuthenticateResult> LoginDevUser(HttpContext context, IDynamicsClient dynamicsClient)
{
string userId = null;
string devCompanyId = null;
bool isDeveloperLogin = false;
bool isBCSCDeveloperLogin = false;
UserSettings userSettings = new UserSettings();
// check for a fake BCeID login
string temp = context.Request.Cookies[_options.DevAuthenticationTokenKey];
if (string.IsNullOrEmpty(temp)) // could be an automated test user.
{
temp = context.Request.Headers["DEV-USER"];
}
if (!string.IsNullOrEmpty(temp))
{
if (temp.Contains("::"))
{
var temp2 = temp.Split("::");
userId = temp2[0];
if (temp2.Length >= 2)
{
devCompanyId = temp2[1];
}
else
{
devCompanyId = temp2[0];
}
}
else
{
userId = temp;
devCompanyId = temp;
}
isDeveloperLogin = true;
_logger.Debug("Got user from dev cookie = " + userId + ", company = " + devCompanyId);
}
else
{
// same set of tests for a BC Services Card dev login
temp = context.Request.Cookies[_options.DevBCSCAuthenticationTokenKey];
if (string.IsNullOrEmpty(temp)) // could be an automated test user.
{
temp = context.Request.Headers["DEV-BCSC-USER"];
}
if (!string.IsNullOrEmpty(temp))
{
userId = temp;
isBCSCDeveloperLogin = true;
_logger.Debug("Got user from dev cookie = " + userId);
}
}
if (isDeveloperLogin)
{
_logger.Debug("Generating a Development user");
userSettings.BusinessLegalName = devCompanyId + " TestBusiness";
userSettings.UserDisplayName = userId + " TestUser";
userSettings.SiteMinderGuid = GuidUtility.CreateIdForDynamics("contact", userSettings.UserDisplayName).ToString();
userSettings.SiteMinderBusinessGuid = GuidUtility.CreateIdForDynamics("account", userSettings.BusinessLegalName).ToString();
userSettings.UserType = "Business";
}
else if (isBCSCDeveloperLogin)
{
_logger.Debug("Generating a Development BC Services user");
userSettings.BusinessLegalName = null;
userSettings.UserDisplayName = userId + " Associate";
userSettings.SiteMinderGuid = GuidUtility.CreateIdForDynamics("bcsc", userSettings.UserDisplayName).ToString();
userSettings.SiteMinderBusinessGuid = null;
userSettings.UserType = "VerifiedIndividual";
}
NameValueCollection queryStringParams = HttpUtility.ParseQueryString(context.Request.QueryString.ToString());
if (queryStringParams.Get("path") == "cannabis-associate-screening" && queryStringParams.Get("success") == "false")
{
context.Request.Headers.Add("smgov_givenname", "NORMAN");
context.Request.Headers.Add("smgov_givennames", "Norman Percevel ");
context.Request.Headers.Add("smgov_useremail", "*****@*****.**");
context.Request.Headers.Add("smgov_birthdate", "1986-12-03");
context.Request.Headers.Add("smgov_sex", "Male");
context.Request.Headers.Add("smgov_streetaddress", "2000 STORMAN ROW");
context.Request.Headers.Add("smgov_city", "PENTICTON");
context.Request.Headers.Add("smgov_postalcode", "V8V8V8");
context.Request.Headers.Add("smgov_province", "BC");
context.Request.Headers.Add("smgov_country", "CA");
context.Request.Headers.Add("smgov_surname", "ROCKWELL");
userSettings.UserDisplayName = "NORMAN ROCKWELL";
}
else if (queryStringParams.Get("path") == "cannabis-associate-screening")
{
context.Request.Headers.Add("smgov_givenname", "JOE");
context.Request.Headers.Add("smgov_givennames", "Joe Shmoe ");
context.Request.Headers.Add("smgov_useremail", "*****@*****.**");
context.Request.Headers.Add("smgov_birthdate", "1986-12-03");
context.Request.Headers.Add("smgov_sex", "Male");
context.Request.Headers.Add("smgov_streetaddress", "2000 COLONIAL ROW");
context.Request.Headers.Add("smgov_city", "PENTICTON");
context.Request.Headers.Add("smgov_postalcode", "V2A7P4");
context.Request.Headers.Add("smgov_province", "BC");
context.Request.Headers.Add("smgov_country", "CA");
context.Request.Headers.Add("smgov_surname", "ONE");
userSettings.UserDisplayName = "JOE ONE";
userSettings.ContactId = "3c254b30-ebf2-ea11-b81d-00505683fbf4";
}
_logger.Debug("DEV MODE Setting identity and creating session for: " + userId);
// create session info for the current user
userSettings.AuthenticatedUser = await _dynamicsClient.LoadUser(userSettings.SiteMinderGuid, context.Request.Headers, _ms_logger);
if (userSettings.AuthenticatedUser == null)
{
userSettings.UserAuthenticated = true;
userSettings.IsNewUserRegistration = true;
}
else
{
userSettings.AuthenticatedUser.UserType = userSettings.UserType;
userSettings.AccountId = userSettings.AuthenticatedUser.AccountId.ToString();
userSettings.ContactId = userSettings.AuthenticatedUser.ContactId.ToString();
userSettings.UserAuthenticated = true;
userSettings.IsNewUserRegistration = false;
}
userSettings.UserId = userId;
ClaimsPrincipal userPrincipal = userSettings.AuthenticatedUser.ToClaimsPrincipal(_options.Scheme, userSettings.UserType);
UserSettings.SaveUserSettings(userSettings, context);
return(AuthenticateResult.Success(new AuthenticationTicket(userPrincipal, null, _options.Scheme)));
}
private ForretningsmeldingEnvelope LagForretningsmeldingEnvelope(Forsendelse forsendelse, AsicEArkiv arkiv,
GuidUtility guidHandler)
{
var forretningsmeldingEnvelope =
new ForretningsmeldingEnvelope(new EnvelopeSettings(forsendelse, arkiv, _databehandler, guidHandler,
_klientkonfigurasjon));
return forretningsmeldingEnvelope;
}
public virtual Guid GenerateCategoryAllProductsPageId(string categoryId)
{
return(GuidUtility.Create(CategoriesNamespaces.AllProductsNamespaceId, categoryId));
}
private static Transportkvittering ValiderTransportkvittering(string meldingsformidlerRespons,
XmlDocument forretningsmeldingEnvelope, GuidUtility guidHandler)
{
try
{
var valideringAvRespons = new Responsvalidator(meldingsformidlerRespons, forretningsmeldingEnvelope);
valideringAvRespons.ValiderHeaderSignatur();
valideringAvRespons.ValiderDigest(guidHandler);
}
catch (Exception e)
{
var transportFeiletKvittering = KvitteringFactory.GetTransportkvittering(meldingsformidlerRespons);
if (transportFeiletKvittering is TransportOkKvittering)
{
throw new SdpSecurityException("Validering av signatur og digest på respons feilet.", e);
}
return transportFeiletKvittering;
}
return KvitteringFactory.GetTransportkvittering(meldingsformidlerRespons);
}
public Guid CreateGuid(Client client)
{
return(GuidUtility.Create(guidNamespace, client.ClientId));
}
/// <summary>
/// Sender en forsendelse til meldingsformidler. Dersom noe feilet i sendingen til meldingsformidler, vil det kastes en exception.
/// </summary>
/// <param name="forsendelse">Et objekt som har all informasjon klar til å kunne sendes (mottakerinformasjon, sertifikater, vedlegg mm), enten digitalt eller fysisk.</param>
/// <param name="lagreDokumentpakke">Hvis satt til true, så lagres dokumentpakken på Klientkonfigurasjon.StandardLoggSti.</param>
public async Task<Transportkvittering> SendAsync(Forsendelse forsendelse, bool lagreDokumentpakke = false)
{
Logging.Log(TraceEventType.Information, forsendelse.KonversasjonsId, "Sender ny forsendelse til meldingsformidler.");
var guidHandler = new GuidUtility();
var arkiv = LagAsicEArkiv(forsendelse, lagreDokumentpakke, guidHandler);
var forretningsmeldingEnvelope = LagForretningsmeldingEnvelope(forsendelse, arkiv, guidHandler);
Logg(TraceEventType.Verbose, forsendelse.KonversasjonsId, arkiv.Signatur.Xml().OuterXml, true, true, "Sendt - Signatur.xml");
Logg(TraceEventType.Verbose, forsendelse.KonversasjonsId, arkiv.Manifest.Xml().OuterXml, true, true, "Sendt - Manifest.xml");
Logg(TraceEventType.Verbose, forsendelse.KonversasjonsId, forretningsmeldingEnvelope.Xml().OuterXml, true, true, "Sendt - Envelope.xml");
try
{
ValiderForretningsmeldingEnvelope(forretningsmeldingEnvelope.Xml());
ValiderArkivManifest(arkiv.Manifest.Xml());
ValiderArkivSignatur(arkiv.Signatur.Xml());
}
catch (Exception e)
{
throw new Exception("Sending av forsendelse feilet under validering. Feilmelding: " + e.GetBaseException(), e.InnerException);
}
var soapContainer = LagSoapContainer(forretningsmeldingEnvelope, arkiv);
var meldingsformidlerRespons = await SendSoapContainer(soapContainer);
Logg(TraceEventType.Verbose, forsendelse.KonversasjonsId, meldingsformidlerRespons, true, true, "Mottatt - Meldingsformidlerespons.txt");
Logg(TraceEventType.Verbose, forsendelse.KonversasjonsId, new byte[1], true,false, "Sendt - SOAPContainer.txt");
Logging.Log(TraceEventType.Information, forsendelse.KonversasjonsId, "Kvittering for forsendelse" + Environment.NewLine + meldingsformidlerRespons);
return ValiderTransportkvittering(meldingsformidlerRespons, forretningsmeldingEnvelope.Xml(), guidHandler);
}
protected override async Task <IImmutableList <Exception> > WriteMessagesAsync(IEnumerable <Akka.Persistence.AtomicWrite> messages)
{
var writeTasks = messages.Select(async message =>
{
try
{
// Journal entries grouped by aggregate
var journalEntries = ((IImmutableList <IPersistentRepresentation>)message.Payload)
.Select(ToJournalEntry)
.GroupBy(x => x.PersistenceId)
.ToList();
// TODO : if there are more than one gropuing then we should use a transaction to write
// to ensure messages writen atomically
var transactionRequired = journalEntries.Count() > 1;
if (transactionRequired)
{
// this is not supported by eventstore, transactions are per stream
// I think we should never get here..
_log.Warning("Multiple aggregates persisted in single write, transaction required!");
}
foreach (var grouping in journalEntries)
{
var streamName = GetStreamName(grouping.Key, _extension.TenantIdentifier);
var representations = grouping.OrderBy(x => x.SequenceNr).ToArray();
// Eventstore sequences starts at 0 Akka starts at 1.
// Expected version is one less than the version of the first item, minus one more to account for the
// Zero based indexing
var firstEventVersion = representations.First().SequenceNr - 1L;
// If Version is 0 then then we are creating a new stream!!
var streamVersion = firstEventVersion < 1L ?
ExpectedVersion.NoStream : // this is a new stream
(firstEventVersion - 1); // Our event should have a version one larger than the current stream version
var events = representations.Select(x =>
{
var eventId = GuidUtility.Create(
GuidUtility.IsoOidNamespace,
string.Concat(streamName, x.SequenceNr)
);
var payload = x.Payload;
var payloadName = payload.GetType().Name;
IDictionary <string, object> metaData = null;
var property = payload.GetType().GetProperty(MetaDataPropertyName, BindingFlags.Instance | BindingFlags.NonPublic);
if (property != null)
{
metaData = property.GetValue(x.Payload) as IDictionary <string, object>;
}
if (metaData == null)
{
metaData = new Dictionary <string, object>();
}
// Store message and payload data types in metta data
metaData[MetaPayloadType] = string.Format($"{payload.GetType().FullName}, {payload.GetType().Assembly.GetName().Name}");
metaData[JournalRepresentatioType] = string.Format($"{typeof(JournalRepresentation).FullName}, {typeof(JournalRepresentation).Assembly.GetName().Name}");
metaData[IsDeletedEvent] = false;
byte[] meta = null, data = null;
try
{
var metaJson = JsonConvert.SerializeObject(
metaData,
metaData.GetType(),
metaDataSerializerSettings);
// Converts message body using JSON Serializer
var json = JsonConvert.SerializeObject(x, journalSerializerSettings);
meta = Encoding.UTF8.GetBytes(metaJson);
data = Encoding.UTF8.GetBytes(json);
}
catch (Exception ex)
{
_log.Error(ex, "Failed to serialize Journal Message");
throw;
}
if (streamVersion == ExpectedVersion.NoStream)
{
NotifyNewPersistenceIdAdded(grouping.Key);
}
else
{
NotifyPersistenceIdChange(grouping.Key);
}
return(new EventData(eventId, payloadName, true, data, meta));
}).ToList();
var connection = await GetConnection();
// See : Write paging
// https://geteventstore.com/blog/20130220/getting-started-part-2-implementing-the-commondomain-repository-interface/index.html
await connection.AppendToStreamAsync(streamName, streamVersion, events);
}
OnAfterJournalEventsPersisted(persistenceIds: journalEntries.Select(e => e.Key));
}
catch (Exception e)
{
if (e is global::EventStore.ClientAPI.Exceptions.EventStoreConnectionException)
{
_log.Error(e, "EventStore Error writing messages to store");
}
else
{
_log.Error(e, "Unexpected Error writing messages to store");
}
throw;
}
});
var result = await Task <IImmutableList <Exception> >
.Factory
.ContinueWhenAll(
writeTasks.ToArray(),
tasks => tasks?.Select(t =>
{
return(t.IsFaulted ? TryUnwrapException(t.Exception) : null);
}).ToImmutableList()
);
return(result);
}
public HashedStringGuidSource(string @string)
{
_string = @string;
_guid = GuidUtility.CreateEnergisticsEtpGuid(@string ?? string.Empty);
}
/// <summary>
/// Convert a given voteQuestion to a ViewModel
/// </summary>
public static ViewModels.AdoxioEstablishment ToViewModel(this MicrosoftDynamicsCRMadoxioEstablishment adoxio_establishment)
{
ViewModels.AdoxioEstablishment result = null;
if (adoxio_establishment != null)
{
result = new ViewModels.AdoxioEstablishment();
if (adoxio_establishment.AdoxioEstablishmentid != null)
{
result.id = adoxio_establishment.AdoxioEstablishmentid.ToString();
}
result._licencee_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioLicenceeValue);
result._licencetypeid_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioLicencetypeidValue);
//result._municipality_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioMunicipalityValue);
result._policejurisdiction_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioPdjurisdictionValue);
result._primaryinspectorid_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioPrimaryinspectoridValue);
result._territory_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._adoxioTerritoryValue);
result._createdby_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._createdbyValue);
result._createdonbehalfby_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._createdonbehalfbyValue);
result._modifiedby_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._modifiedbyValue);
result._modifiedonbehalfby_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._modifiedonbehalfbyValue);
result._ownerid_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._owneridValue);
result._owningbusinessunit_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._owningbusinessunitValue);
result._owningteam_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._owningteamValue);
result._owninguser_value = GuidUtility.SafeNullableGuidConvert(adoxio_establishment._owninguserValue);
result.Addresscity = adoxio_establishment.AdoxioAddresscity;
result.Addresspostalcode = adoxio_establishment.AdoxioAddresspostalcode;
result.Addressstreet = adoxio_establishment.AdoxioAddressstreet;
result.Alreadyopen = adoxio_establishment.AdoxioAlreadyopen;
result.Email = adoxio_establishment.AdoxioEmail;
result.Expectedopendate = adoxio_establishment.AdoxioExpectedopendate;
result.Fridayclose = adoxio_establishment.AdoxioFridayclose;
result.Fridayopen = adoxio_establishment.AdoxioFridayopen;
result.Hasduallicence = adoxio_establishment.AdoxioHasduallicence;
result.Isrural = adoxio_establishment.AdoxioIsrural;
result.Isstandalonepatio = adoxio_establishment.AdoxioIsstandalonepatio;
result.Locatedatwinery = adoxio_establishment.AdoxioLocatedatwinery;
result.Locatedonfirstnationland = adoxio_establishment.AdoxioLocatedonfirstnationland;
result.Mailsenttorestaurant = adoxio_establishment.AdoxioMailsenttorestaurant;
result.Mondayclose = adoxio_establishment.AdoxioMondayclose;
result.Mondayopen = adoxio_establishment.AdoxioMondayopen;
result.Name = adoxio_establishment.AdoxioName;
result.Occupantcapacity = adoxio_establishment.AdoxioOccupantcapacity;
result.Occupantload = adoxio_establishment.AdoxioOccupantload;
result.Parcelid = adoxio_establishment.AdoxioParcelid;
result.Patronparticipation = adoxio_establishment.AdoxioPatronparticipation;
result.Phone = adoxio_establishment.AdoxioPhone;
result.Saturdayclose = adoxio_establishment.AdoxioSaturdayclose;
result.Saturdayopen = adoxio_establishment.AdoxioSaturdayopen;
result.Sendmailtoestablishmentuponapproval = adoxio_establishment.AdoxioSendmailtoestablishmentuponapproval;
result.Standardhours = adoxio_establishment.AdoxioStandardhours;
result.Sundayclose = adoxio_establishment.AdoxioSundayclose;
result.Sundayopen = adoxio_establishment.AdoxioSundayopen;
result.Thursdayclose = adoxio_establishment.AdoxioThursdayclose;
result.Thursdayopen = adoxio_establishment.AdoxioThursdayopen;
result.Tuesdayclose = adoxio_establishment.AdoxioTuesdayclose;
result.Tuesdayopen = adoxio_establishment.AdoxioTuesdayopen;
result.Wednesdayclose = adoxio_establishment.AdoxioWednesdayclose;
result.Wednesdayopen = adoxio_establishment.AdoxioWednesdayopen;
result.Createdon = adoxio_establishment.Createdon;
result.Importsequencenumber = adoxio_establishment.Importsequencenumber;
result.Modifiedon = adoxio_establishment.Modifiedon;
result.Overriddencreatedon = adoxio_establishment.Overriddencreatedon;
result.StatusCode = adoxio_establishment.Statuscode;
result.StateCode = adoxio_establishment.Statecode;
result.Timezoneruleversionnumber = adoxio_establishment.Timezoneruleversionnumber;
result.Utcconversiontimezonecode = adoxio_establishment.Utcconversiontimezonecode;
if (adoxio_establishment.Versionnumber != null)
{
result.Versionnumber = adoxio_establishment.Versionnumber;
}
}
return(result);
}
public AncestorGenerator(GuidUtility guidUtility = null)
{
_guidUtility = guidUtility ?? new GuidUtility();
}
public static void Main(string[] args)
{
try
{
if (Process.GetCurrentProcess().SessionId <= 0)
{
try
{
LoggerUtil.GetAppWideLogger().Error("GUI client started in session 0 isolation. Exiting. This should not happen.");
Environment.Exit((int)ExitCodes.ShutdownWithoutSafeguards);
return;
}
catch (Exception e)
{
// XXX TODO - We can't really log here unless we do a direct to-file write.
Environment.Exit((int)ExitCodes.ShutdownWithoutSafeguards);
return;
}
}
}
catch
{
// Lets assume that if we can't even read our session ID, that we're in session 0.
Environment.Exit((int)ExitCodes.ShutdownWithoutSafeguards);
return;
}
try
{
string appVerStr = System.Diagnostics.Process.GetCurrentProcess().ProcessName;
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
appVerStr += "." + System.Reflection.AssemblyName.GetAssemblyName(assembly.Location).Version.ToString();
bool createdNew;
try
{
InstanceMutex = new Mutex(true, string.Format(@"Local\{0}", GuidUtility.Create(GuidUtility.DnsNamespace, appVerStr).ToString("B")), out createdNew);
}
catch
{
// We can get access denied if SYSTEM is running this.
createdNew = false;
}
if (!createdNew)
{
try
{
var thisProcess = Process.GetCurrentProcess();
var processes = Process.GetProcessesByName(thisProcess.ProcessName).Where(p => p.Id != thisProcess.Id);
foreach (Process runningProcess in processes)
{
foreach (var handle in WindowHelpers.EnumerateProcessWindowHandles(runningProcess.Id))
{
// Send window show.
WindowHelpers.SendMessage(handle, (uint)WindowMessages.SHOWWINDOW, 9, 0);
}
}
}
catch (Exception e)
{
LoggerUtil.RecursivelyLogException(LoggerUtil.GetAppWideLogger(), e);
}
// In case we have some out of sync state where the app is running at a higher
// privilege level than us, the app won't get our messages. So, let's attempt an
// IPC named pipe to deliver the message as well.
try
{
using (var ipcClient = new IPCClient())
{
ipcClient.RequestPrimaryClientShowUI();
// Wait plenty of time before dispose to allow delivery of the msg.
Task.Delay(500).Wait();
}
}
catch (Exception e)
{
// The only way we got here is if the server isn't running, in which case we
// can do nothing because its beyond our domain.
LoggerUtil.RecursivelyLogException(LoggerUtil.GetAppWideLogger(), e);
}
// Close this instance.
Environment.Exit(-1);
return;
}
}
catch (Exception e)
{
// The only way we got here is if the server isn't running, in which case we can do
// nothing because its beyond our domain.
LoggerUtil.RecursivelyLogException(LoggerUtil.GetAppWideLogger(), e);
return;
}
try
{
MainLogger = LoggerUtil.GetAppWideLogger();
}
catch { }
try
{
var app = new CitadelApp();
app.InitializeComponent();
app.Run();
// Always release mutex.
InstanceMutex.ReleaseMutex();
}
catch (Exception e)
{
try
{
MainLogger = LoggerUtil.GetAppWideLogger();
LoggerUtil.RecursivelyLogException(MainLogger, e);
}
catch (Exception be)
{
// XXX TODO - We can't really log here unless we do a direct to-file write.
}
}
// No matter what, always ensure that critical flags are removed from our process before exiting.
CriticalKernelProcessUtility.SetMyProcessAsNonKernelCritical();
}
private Item InstallValue(DemandbaseAttribute attribute, string value, Item valueFolder)
{
Item ret = valueFolder.Database.DataManager.DataEngine.CreateItem(ItemUtil.ProposeValidItemName(value), valueFolder,
new ID(DemandbaseConstants.ValueTemplateId), GuidUtility.GetId("demandbasevalue" + valueFolder.ID + attribute.Id, value));
ret.BeginVersionCheckEditing();
ret["Value"] = value;
ret.Editing.EndEdit();
return(ret);
}
private Item InstallValueFolder(DemandbaseAttribute attribute, Item defaultValuesFolder)
{
Item folder = defaultValuesFolder.Database.DataManager.DataEngine.CreateItem(ItemUtil.ProposeValidItemName(attribute.Name),
defaultValuesFolder, new ID(DemandbaseConstants.ValueListTemplateId),
GuidUtility.GetId("demandbasevaluefolder" + defaultValuesFolder.ID, attribute.Id));
folder.BeginVersionCheckEditing();
folder["Attribute Id"] = attribute.Id;
folder.Editing.EndEdit();
foreach (string value in attribute.DefaultValues)
{
InstallValue(attribute, value, folder);
}
return(folder);
}
public static void CompareWorkspacesDifferentGuids(serializationTestUtils.WorkspaceComparisonData a,
serializationTestUtils.WorkspaceComparisonData b,
Dictionary <Guid, string> modelGuidsToIDmap)
{
var nodeDiff = a.NodeTypeMap.Select(x => x.Value).Except(b.NodeTypeMap.Select(x => x.Value));
if (nodeDiff.Any())
{
Assert.Fail("The workspaces don't have the same number of nodes. The json workspace is missing: " + string.Join(",", nodeDiff.Select(i => i.ToString())));
}
Assert.AreEqual(a.NodeCount, b.NodeCount, "The workspaces don't have the same number of nodes.");
Assert.AreEqual(a.ConnectorCount, b.ConnectorCount, "The workspaces don't have the same number of connectors.");
foreach (var kvp in a.InportCountMap)
{
var countA = kvp.Value;
//convert the old guid to the new guid
var newGuid = GuidUtility.Create(GuidUtility.UrlNamespace, modelGuidsToIDmap[kvp.Key]);
var countB = b.InportCountMap[newGuid];
Assert.AreEqual(countA, countB, string.Format("One {0} node has {1} inports, while the other has {2}", a.NodeTypeMap[kvp.Key], countA, countB));
}
foreach (var kvp in a.OutportCountMap)
{
var countA = kvp.Value;
//convert the old guid to the new guid
var newGuid = GuidUtility.Create(GuidUtility.UrlNamespace, modelGuidsToIDmap[kvp.Key]);
var countB = b.OutportCountMap[newGuid];
Assert.AreEqual(countA, countB, string.Format("One {0} node has {1} outports, while the other has {2}", a.NodeTypeMap[kvp.Key], countA, countB));
}
foreach (var portkvp in a.PortDataMap)
{
//convert the old guid to the new guid
var newGuid = GuidUtility.Create(GuidUtility.UrlNamespace, modelGuidsToIDmap[portkvp.Key]);
Assert.IsTrue(b.PortDataMap.ContainsKey(newGuid));
var aPort = a.PortDataMap[portkvp.Key];
var bPort = b.PortDataMap[newGuid];
Assert.AreEqual(aPort.UseLevels, bPort.UseLevels);
Assert.AreEqual(aPort.KeepListStructure, bPort.KeepListStructure);
Assert.AreEqual(aPort.Level, bPort.Level);
Assert.AreEqual(aPort.Description, bPort.Description);
}
foreach (var kvp in a.NodeReplicationMap)
{
var newGuid = GuidUtility.Create(GuidUtility.UrlNamespace, modelGuidsToIDmap[kvp.Key]);
var valueA = kvp.Value;
var valueB = b.NodeReplicationMap[newGuid];
Assert.AreEqual(valueA, valueB);
}
foreach (var kvp in a.NodeDataMap)
{
var valueA = kvp.Value;
//convert the old guid to the new guid
var newGuid = GuidUtility.Create(GuidUtility.UrlNamespace, modelGuidsToIDmap[kvp.Key]);
var valueB = b.NodeDataMap[newGuid];
Assert.AreEqual(a.NodeTypeMap[kvp.Key], b.NodeTypeMap[newGuid]);
try
{
// When values are geometry, sometimes the creation
// of the string representation for forming this message
// fails.
Assert.AreEqual(valueA, valueB,
string.Format("Node Type:{0} value, {1} is not equal to {2}",
a.NodeTypeMap[kvp.Key], valueA, valueB));
}
catch
{
continue;
}
}
}
private IEnumerable <DemandbaseAttribute> ProcessXmlAttributes(Item attributesFolder, XmlNodeList attributes, Database db, Item defaultValuesFolder, bool accountWatch)
{
using (new SecurityDisabler())
{
if (attributes != null)
{
foreach (XmlNode key in attributes)
{
var attribute = new DemandbaseAttribute(key, accountWatch);
yield return(attribute);
if (!_generate)
{
continue;
}
Item itemAttribute = null;
if (attribute.Customizable || (!attribute.Customizable && !attribute.DefaultValues.Any()))
{
itemAttribute = db.GetItem(GuidUtility.GetId("demandbase" + FindParent(attribute, db).ID, attribute.Id));
if (itemAttribute == null || itemAttribute["Name"] != attribute.Name || itemAttribute["Id"] != attribute.Id)
{
itemAttribute = InstallAttribute(attribute, attributesFolder);
}
DemandbaseScrubber.tracker.Add(itemAttribute.ID);
}
Item valueFolder = null;
valueFolder = db.GetItem(GuidUtility.GetId("demandbasevaluefolder" + defaultValuesFolder.ID, attribute.Id));
if (valueFolder == null && attribute.DefaultValues.Any())
{
valueFolder = InstallValueFolder(attribute, defaultValuesFolder);
}
else if (valueFolder != null)
{
if (valueFolder["Attribute Id"] != attribute.Id)
{
valueFolder.BeginVersionCheckEditing();
valueFolder["Attribute Id"] = attribute.Id;
valueFolder.Editing.EndEdit();
}
foreach (Item valueItem in valueFolder.Children.Where(x => !attribute.DefaultValues.Contains(x["Value"])))
{
valueItem.Delete();
}
foreach (string value in attribute.DefaultValues)
{
Item valueItem = db.GetItem(GuidUtility.GetId("demandbasevalue" + defaultValuesFolder.ID + attribute.Id, value)) ??
InstallValue(attribute, value, valueFolder);
if (valueItem["Value"] == value)
{
continue;
}
valueItem.BeginVersionCheckEditing();
valueItem["Value"] = value;
valueItem.Editing.EndEdit();
}
}
if (attribute.DefaultValues.Any())
{
DemandbaseScrubber.tracker.Add(valueFolder.ID);
}
}
}
}
}
/// <summary>
/// Sender en <see cref="Forsendelse" /> til Meldingsformidler.
/// </summary>
/// <param name="forsendelse">
/// All informasjon, klar til å kunne sendes (mottakerinformasjon, sertifikater,
/// vedlegg mm), enten digitalt eller fysisk.
/// </param>
public async Task<Transportkvittering> SendAsync(Forsendelse forsendelse)
{
var guidUtility = new GuidUtility();
Log.Debug($"Utgående forsendelse, conversationId '{forsendelse.KonversasjonsId}', messageId '{guidUtility.MessageId}'.");
var documentBundle = AsiceGenerator.Create(forsendelse, guidUtility, Databehandler.Sertifikat, Klientkonfigurasjon);
var forretningsmeldingEnvelope = new ForretningsmeldingEnvelope(new EnvelopeSettings(forsendelse, documentBundle, Databehandler, guidUtility, Klientkonfigurasjon));
ValidateEnvelopeAndThrowIfInvalid(forretningsmeldingEnvelope, forretningsmeldingEnvelope.GetType().Name);
var transportReceipt = (Transportkvittering) await RequestHelper.SendMessage(forretningsmeldingEnvelope, documentBundle).ConfigureAwait(false);
transportReceipt.AntallBytesDokumentpakke = documentBundle.BillableBytes;
var transportReceiptXml = XmlUtility.TilXmlDokument(transportReceipt.Rådata);
if (transportReceipt is TransportOkKvittering)
{
Log.Debug($"{transportReceipt}");
var responsvalidator = new ResponseValidator(forretningsmeldingEnvelope.Xml(), transportReceiptXml, Klientkonfigurasjon.Miljø.CertificateChainValidator);
responsvalidator.ValidateTransportReceipt(guidUtility);
}
else
{
Log.Error($"{transportReceipt}");
}
return transportReceipt;
}
/// <summary>
/// Sjekker at motatt soap dokument har samme digest verdier for body og dokumentpakke i avsendt brev vha motatt
/// NonRepudiationInformation element.
/// </summary>
/// <param name="guidHandler">Samme guid handler som ble benyttet for å generere det avsendte brevet.</param>
private void ValidateDigest(GuidUtility guidHandler)
{
var sentMessageDigestPath = "/env:Envelope/env:Header/wsse:Security/ds:Signature/ds:SignedInfo/ds:Reference[@URI='{0}']/ds:DigestValue";
var receivedMessageDigestPath = "/env:Envelope/env:Header/eb:Messaging/eb:SignalMessage/eb:Receipt/ebbp:NonRepudiationInformation/ebbp:MessagePartNRInformation/ds:Reference[@URI='{0}']/ds:DigestValue";
var ids = new List<string>
{
$"#{guidHandler.BodyId}",
$"cid:{guidHandler.DokumentpakkeId}"
};
foreach (var id in ids)
{
string sentMessageDigest;
string reveivedMessageDigest;
var isValidDigest = ValidateDigestElement(sentMessageDigestPath, receivedMessageDigestPath, id, out sentMessageDigest, out reveivedMessageDigest);
if (!isValidDigest)
{
throw new SdpSecurityException($"Digest verdien av uri {id} for sendt melding ({sentMessageDigest}) matcher ikke motatt digest ({reveivedMessageDigest}).");
}
}
}
