public new object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
//var result = base.ReadWithMapping(node, reader, parsers);
var result = base.ReadWithMapping(node, reader, parsers);
return(result);
}
public DocumentChangeFileMarkValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser, INodesService nodesService)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Document)
.WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.Document}.");
});
}
public DocumentForSignatureValidator(
IAlfrescoHttpClient alfrescoHttpClient,
IIdentityUser identityUser,
IAlfrescoConfiguration alfrescoConfiguration,
ISimpleMemoryCache simpleMemoryCache,
ISystemLoginService systemLoginService)
{
var adminHttpClient = new AlfrescoHttpClient(alfrescoConfiguration, new AdminAuthentification(simpleMemoryCache, alfrescoConfiguration, systemLoginService));
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, $"{AlfrescoNames.Includes.Path}", ParameterType.QueryString)));
_groupPagingCurrentUser = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
_groupPagingNextOwner = await adminHttpClient.GetPersonGroups(context.Body.User);
return(_nodeEntry?.Entry?.Id != null && _groupPagingCurrentUser != null && _groupPagingNextOwner != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPagingCurrentUser?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x)
.Must(y => _groupPagingNextOwner?.List?.Entries?.Any(q => q.Entry.Id == $"{y.Body.Group}_Sign") ?? false)
.WithName(x => "Group")
.WithMessage("User for signing isn't member of group with postfix _Sign.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Document)
.WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.Document}.");
RuleFor(x => x)
.Must(x => _nodeEntry?.Entry?.Path?.Name?.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.Evidence, StringComparison.OrdinalIgnoreCase) == true)
.OnAnyFailure(x => throw new BadRequestException("Document must be in evidence site."));
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceDocumentsForProcessing(identityUser.RequestGroup)) ||
_nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceFilesDocumentsForProcessing(identityUser.RequestGroup)))
.WithMessage($"NodeId must be in path {SpisumNames.Paths.EvidenceDocumentsForProcessing(identityUser.RequestGroup)} or {SpisumNames.Paths.EvidenceFilesDocumentsForProcessing(identityUser.RequestGroup)}.");
});
RuleFor(x => x)
.Must(x => !string.IsNullOrEmpty(x?.Body?.User))
.When(x => x?.Body != null)
.WithName(x => nameof(x.Body.User))
.WithMessage("You have to fill user.");
RuleFor(x => x)
.Must(x => !string.IsNullOrEmpty(x?.Body?.Group))
.When(x => x?.Body != null)
.WithName(x => nameof(x.Body.Group))
.WithMessage("You have to fill group.");
}
public ConceptComponentUpdateContentValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
_nodeParents = await alfrescoHttpClient.GetNodeParents(context.ComponentId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Properties, ParameterType.QueryString))
.Add(new Parameter(AlfrescoNames.Headers.Where,
$"(assocType='{SpisumNames.Associations.Components}')"
, ParameterType.QueryString)));
return(_nodeEntry?.Entry?.Id != null && _groupPaging != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Concept)
.WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.Concept}.");
RuleFor(x => x)
.Must(c => _nodeParents?.List?.Entries?.Any(y => y?.Entry?.Id == c.NodeId) ?? false)
.WithMessage("Provided component is not associated with nodeId or cannot be canceled.");
});
}
public void Write(NodeWriter writer, NodeEntry node)
{
var data = (JournalManager)node.Value;
writer.Write(data.Entries.Count);
foreach (var entry in data.Entries)
{
writer.Write(entry.Unk1_PathHash);
writer.Write(entry.Unk2_State);
writer.Write(entry.Unknown3);
writer.Write(entry.Unknown4);
}
writer.Write(data.Unk1_TrackedQuestPath);
writer.Write(data.Unknown2.Count);
foreach (var entry in data.Unknown2)
{
writer.Write(entry);
}
writer.Write(data.Unknown3.Count);
foreach (var entry in data.Unknown3)
{
writer.Write(entry.Unknown1);
writer.Write(entry.Unknown2);
writer.Write(entry.Unknown3);
writer.Write(entry.Unknown4);
}
writer.Write(data.TrailingBytes);
}
public object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
var result = new QuestMusicHistory();
reader.Skip(4);
var count = reader.ReadUInt32();
for (int i = 0; i < count; i++)
{
var entry = new QuestMusicHistory.Entry();
entry.Unknown1 = reader.ReadTweakDbId();
entry.Unknown2 = reader.ReadUInt64();
entry.Unknown3 = reader.ReadUInt64();
entry.Unknown4 = reader.ReadUInt16();
entry.Unknown5 = reader.ReadUInt16();
entry.Unknown6 = reader.ReadUInt32();
result.Entries.Add(entry);
}
result.Node = node;
return(result);
}
private static void WriteXmlNode(XmlWriter writer, List <NodeEntry> nodes, NodeEntry node)
{
writer.WriteStartElement(node.Name.ToString());
foreach (var attribute in node.Attributes)
{
writer.WriteStartAttribute(attribute.Name.ToString());
writer.WriteValue(attribute.Value == null ? "" : attribute.Value.ToString());
writer.WriteEndAttribute();
}
foreach (var childId in node.Children)
{
var child = nodes.SingleOrDefault(n => n.Id == childId);
if (child == null)
{
throw new KeyNotFoundException();
}
WriteXmlNode(writer, nodes, child);
}
if (node.Value != null)
{
if (node.Value.Type != DataType.String)
{
writer.WriteAttributeString("__type", DataTypeToString(node.Value.Type));
}
writer.WriteValue(node.Value.ToString());
}
writer.WriteEndElement();
}
//HELPERS
protected override NetworkInterface getRoute(Node destination)
{
IntervalHeap <NodeEntry> sortedNodes = new IntervalHeap <NodeEntry>();
HashDictionary <Node, NodeEntry> hashedNodes = new HashDictionary <Node, NodeEntry>();
NodeEntry thisNode = new NodeEntry();
thisNode.Node = node;
thisNode.Time = Timer.CurrentTime;
bool added = sortedNodes.Add(ref thisNode.Handle, thisNode);
NodeEntry temp;
bool found = sortedNodes.Find(thisNode.Handle, out temp);
Debug.Assert(found);
Debug.Assert(added);
hashedNodes.Add(node, thisNode);
double currentTime = -1;
while (sortedNodes.Count > 0)
{
NodeEntry current = sortedNodes.DeleteMin();
Debug.Assert(current.Time >= currentTime);
currentTime = current.Time;
if (current.Node == destination)
{
return(extractInterface(current, hashedNodes));
}
nextMove(current, sortedNodes, hashedNodes);
Debug.Assert(sortedNodes.Check());
}
//route not found
return(null);
}
private static void PopulateCheckGlobalVariableEntry(NodeEntry nodeEntry, Node node, Dictionary <Node, int> nodeMap)
{
ValidateCheckGlobalVariable(node);
// assign node entry data if validated
nodeEntry.nodeType = NodeType.CheckGlobalVariable;
nodeEntry.NID = nodeMap[node];
// assign connected outpoints
if (node.splitter.positiveOutpoint.connections.Count > 0)
{
nodeEntry.outPointPosNID = nodeMap[(Node)node.splitter.positiveOutpoint.connections[0].inPoint.parent];
}
if (node.splitter.negativeOutpoint.connections.Count > 0)
{
nodeEntry.outPointNegNID = nodeMap[(Node)node.splitter.negativeOutpoint.connections[0].inPoint.parent];
}
nodeEntry.flag = TrimGlobalItem(node.globalItemDropdown.selectedItem);
if (string.IsNullOrEmpty(node.globalVariableField.text))
{
nodeEntry.variableValue = "0";
}
else
{
nodeEntry.variableValue = node.globalVariableField.text;
}
}
private static void WriteXmlNode(XmlWriter writer, NodeEntry node)
{
writer.WriteStartElement(node.Name);
foreach (var attribute in node.Attributes)
{
writer.WriteStartAttribute(attribute.Name);
writer.WriteValue(attribute.Value == null
? ""
: attribute.Value.ToString());
writer.WriteEndAttribute();
}
foreach (var child in node.Children)
{
WriteXmlNode(writer, child);
}
if (node.Value != null)
{
writer.WriteValue(node.Value.ToString());
}
writer.WriteEndElement();
}
public DocumentReturnForReworkValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, $"{AlfrescoNames.Includes.Path}", ParameterType.QueryString)));
return(_groupPaging != null && _nodeEntry?.Entry?.Id != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ??
false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceDocumentsForProcessingForSignature(identityUser.RequestGroup)) ||
_nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceFilesDocumentsForProcessingForSignature(identityUser.RequestGroup)))
.WithMessage($"NodeId must be in path {SpisumNames.Paths.EvidenceDocumentsForProcessing(identityUser.RequestGroup)} or {SpisumNames.Paths.EvidenceFilesDocumentsForProcessing(identityUser.RequestGroup)}.");
});
RuleFor(x => x.Body.Reason)
.MinimumLength(4)
.MaximumLength(30)
.When(x => x.Body != null)
.WithMessage("Reason must be at least 4 characters long but maximum 30 characters long");
}
public object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
var result = new EventManager();
reader.Skip(4); // Skip Id
var entryCount = reader.ReadUInt32();
for (int i = 0; i < entryCount; i++)
{
var entry = new EventManager.Entry();
entry.Unknown1 = reader.ReadUInt64();
entry.Unknown2 = reader.ReadUInt32();
entry.Unknown3 = reader.ReadUInt16();
entry.Unknown4 = reader.ReadUInt16();
result.Unknown.Add(entry);
}
int readSize = node.Size - ((int)reader.BaseStream.Position - node.Offset);
result.Node = node;
return(result);
}
public void Write(NodeWriter writer, NodeEntry node)
{
foreach (var child in node.Children)
{
writer.Write(child);
}
}
public void Write(NodeWriter writer, NodeEntry node)
{
var data = (PlayerSystem)node.Value;
writer.Write(data.Unk_Hash);
writer.Write(data.Unk_Id);
}
public static Inventory.SubInventory ReadSubInventory(NodeEntry inventoryNode, uint nodeOffset, BinaryReader reader, List <INodeParser> parsers)
{
var subInventory = new Inventory.SubInventory();
subInventory.InventoryId = reader.ReadUInt64();
var count = reader.ReadUInt32();
var parser = parsers.FirstOrDefault(p => p.ParsableNodeName == Constants.NodeNames.ITEM_DATA);
Debug.Assert(parser != null);
for (var i = 0; i < count; ++i)
{
var nextItemHeader = ItemDataParser.ReadNextItemEntry(reader);
var item = (ItemData)parser.Read(inventoryNode.Children[(int)nodeOffset + i], reader, parsers);
if (!nextItemHeader.BelongsToItemData(item))
{
throw new InvalidDataException($"Expected next item to be '{nextItemHeader}' but found '{item}'");
}
subInventory.Items.Add(item);
inventoryNode.Children[(int)nodeOffset + i].Value = item;
item.Node = inventoryNode.Children[(int)nodeOffset + i];
}
return(subInventory);
}
public void Write(NodeWriter writer, NodeEntry node)
{
var data = (ItemData)node.Value;
writer.Write(data.ItemTdbId);
WriteHeaderThing(writer, data.Header);
writer.Write(data.Flags.Raw);
writer.Write(data.CreationTime);
switch (data.Header.Kind)
{
case 0:
WriteModableItemWithQuantityData(writer, data.Data as ItemData.ModableItemWithQuantityData);
break;
case 1:
WriteSimpleItemData(writer, data.Data as ItemData.SimpleItemData);
break;
case 2:
WriteModableItemData(writer, data.Data as ItemData.ModableItemData);
break;
}
}
public async Task LogHandoverDecline(string nodeId, NodeEntry nodeEntry)
{
try
{
var pid = nodeEntry?.GetPid();
if (nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Concept)
{
await _auditLogService.Record(nodeId, SpisumNames.NodeTypes.Concept, pid, NodeTypeCodes.Dokument, EventCodes.VraceniZAgendy,
TransactinoHistoryMessages.ConceptHandoverDecline);
return;
}
if (nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Document)
{
await _auditLogService.Record(nodeId, SpisumNames.NodeTypes.Document, pid, NodeTypeCodes.Dokument, EventCodes.VraceniZAgendy,
TransactinoHistoryMessages.DocumentHandoverDecline);
return;
}
if (nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.File)
{
await _auditLogService.Record(nodeId, SpisumNames.NodeTypes.File, pid, NodeTypeCodes.Spis, EventCodes.VraceniZAgendy,
TransactinoHistoryMessages.FileHandoverDecline);
}
}
catch (Exception ex)
{
Log.Logger?.Error(ex, "Audit log failed");
}
}
public byte[] Write(NodeEntry node, List <INodeParser> parsers)
{
byte[] result;
var data = (ItemDropStorageManager)node.Value;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII))
{
writer.Write(node.Id);
writer.Write(data.NumberOfItemDropStorages);
var parser = parsers.Where(p => p.ParsableNodeName == Constants.NodeNames.ITEM_DROP_STORAGE).FirstOrDefault();
Debug.Assert(parser != null);
for (var i = 0; i < data.NumberOfItemDropStorages; ++i)
{
writer.Write(parser.Write(node.Children[i], parsers));
}
writer.Write(data.TrailingBytes);
}
result = stream.ToArray();
}
return(result);
}
public static bool IsUserOwner(this NodeEntry nodeEntry, string currentUser)
{
var properties = nodeEntry.Entry.Properties.As <JObject>().ToDictionary();
var contentOwner = properties.GetNestedValueOrDefault(AlfrescoNames.ContentModel.Owner, "id")?.ToString();
return(contentOwner == currentUser || nodeEntry.Entry.CreatedByUser.Id == currentUser);
}
private async Task CreateAllSecondaryChildren(NodeEntry emlFile, List <NodeEntry> attachments)
{
foreach (var attachment in attachments)
{
await CreateSecondaryChildren(emlFile, attachment);
}
}
public void Write(NodeWriter writer, NodeEntry node)
{
var data = (DSDynamicConnections)node.Value;
writer.WritePackedInt(data.Entries.Count);
foreach (var entry in data.Entries)
{
writer.Write(entry.Unknown1);
}
foreach (var entry in data.Entries)
{
writer.WritePackedString(entry.Unknown2);
writer.WritePackedInt(entry.Unknown3.Count);
foreach (var val in entry.Unknown3)
{
writer.Write(val);
}
writer.WritePackedInt(entry.Unknown4.Count);
foreach (var val in entry.Unknown4)
{
writer.Write(val);
}
writer.Write(entry.Unknown5);
writer.WritePackedString(entry.Unknown6);
}
}
private static void PopulateDecisionEntry(NodeEntry nodeEntry, Node node, Dictionary <Node, int> nodeMap)
{
ValidateDecision(node);
// assign node entry data if validated
nodeEntry.nodeType = NodeType.Decision;
nodeEntry.NID = nodeMap[node];
nodeEntry.decisions = new List <DecisionEntry>();
DecisionEntry tempDecisionEntry = new DecisionEntry();
SDEContainer tempChild = node.childContainer;
if (tempChild != null)
{
nodeEntry.decisions.Add(tempDecisionEntry);
while (tempChild != null)
{
// validate each DecisionBox
ValidateDecisionBox((DecisionBox)tempChild);
// assign child entry data if validated
tempDecisionEntry.text = ((DecisionBox)tempChild).textArea.text;
tempDecisionEntry.outPointNID = nodeMap[(Node)tempChild.outPoint.connections[0].inPoint.parent];
tempChild = tempChild.child;
if (tempChild != null)
{
tempDecisionEntry = new DecisionEntry();
nodeEntry.decisions.Add(tempDecisionEntry);
}
}
}
}
public SignerCreateValidator(IAlfrescoHttpClient alfrescoHttpClient)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.DocumentId);
return(_nodeEntry?.Entry?.Id != null);
})
.WithName(x => nameof(x.DocumentId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x.DocumentId)
.Must(x => _nodeEntry?.Entry?.NodeType == SpisumNames.NodeTypes.Document)
.OnAnyFailure(x => throw new BadRequestException($"NodeId {x.DocumentId} must be type of {SpisumNames.NodeTypes.Document}"));
});
RuleFor(x => x)
.Must(x => x.ComponentId != null && x.ComponentId.All(x => !string.IsNullOrEmpty(x)))
.When(x => x != null)
.OnAnyFailure(x => throw new BadRequestException("Component id's can't be null."));
RuleFor(x => x)
.Must(x => !string.IsNullOrEmpty(x.DocumentId))
.When(x => x != null)
.OnAnyFailure(x => throw new BadRequestException("Document id can't be null."));
}
public object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
node.Parser = this;
reader.Skip(4);
var result = new FactsDB();
var count = reader.ReadByte();
// There should be count many children
if (count != node.Children.Count)
{
throw new InvalidDataException($"Expected {count} FactsTable but found {node.Children.Count}.");
}
var parser = parsers.Where(p => p.ParsableNodeName == Constants.NodeNames.FACTS_TABLE).FirstOrDefault();
Debug.Assert(parser != null);
foreach (var child in node.Children)
{
child.Value = (FactsTable)parser.Read(child, reader, parsers);
result.FactsTables.Add((FactsTable)child.Value);
}
// There is a blob between the last factstable and the next node in questsystem
result.TrailingBytes = reader.ReadBytes(node.TrailingSize);
result.Node = node;
return(result);
}
public object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
node.Parser = this;
var result = new FactsTable();
reader.Skip(4); //skip Id
var count = reader.ReadPackedInt();
var tmpFactList = new uint[count];
for (int i = 0; i < count; i++)
{
tmpFactList[i] = reader.ReadUInt32();
}
for (int i = 0; i < count; i++)
{
result.FactEntries.Add(new FactsTable.FactEntry
{
Hash = tmpFactList[i],
Value = reader.ReadUInt32()
});
}
ParserUtils.ParseChildren(node.Children, reader, parsers);
result.Node = node;
return(result);
}
private static NodeEntry RecursiveTestNode(string jointStrings, NodeEntry node)
{
if (jointStrings.IndexOf(node._name) >= 0)
{
return(node);
}
else if (jointStrings.IndexOf(node._sid) >= 0)
{
return(node);
}
else if (jointStrings.IndexOf(node._id) >= 0)
{
return(node);
}
NodeEntry e;
foreach (NodeEntry n in node._children)
{
if ((e = RecursiveTestNode(jointStrings, n)) != null)
{
return(e);
}
}
return(null);
}
public byte[] Write(NodeEntry node, List <INodeParser> parsers)
{
byte[] result;
var data = (FactsDB)node.Value;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII))
{
writer.Write(node.Id);
writer.Write(data.FactsTableCount);
var parser = parsers.Where(p => p.ParsableNodeName == Constants.NodeNames.FACTS_TABLE).FirstOrDefault();
Debug.Assert(parser != null);
foreach (var child in node.Children)
{
writer.Write(parser.Write(child, parsers));
}
writer.Write(data.TrailingBytes);
}
result = stream.ToArray();
}
return(result);
}
public object Read(NodeEntry node, BinaryReader reader, List <INodeParser> parsers)
{
var result = new ItemDropStorageManager();
reader.Skip(4); // Skip Id
result.NumberOfItemDropStorages = reader.ReadUInt32();
result.ItemDropStorages = new ItemDropStorage[result.NumberOfItemDropStorages];
var parser = parsers.Where(p => p.ParsableNodeName == Constants.NodeNames.ITEM_DROP_STORAGE).FirstOrDefault();
Debug.Assert(parser != null);
for (var i = 0; i < result.NumberOfItemDropStorages; ++i)
{
result.ItemDropStorages[i] = (ItemDropStorage)parser.Read(node.Children[i], reader, parsers);
node.Children[i].Value = result.ItemDropStorages[i];
}
int readSize = node.Size - ((int)reader.BaseStream.Position - node.Offset);
Debug.Assert(readSize >= 0);
result.TrailingBytes = reader.ReadBytes(readSize);
return(result);
}
public DocumentFromSignatureValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.Document)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.Document}");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.Path.Name.EndsWith(SpisumNames.Paths.DocumentsForSignature) ||
_nodeEntry.Entry.Path.Name.EndsWith(SpisumNames.Paths.FilesDocumentsForSignature))
.WithMessage(
$"NodeId must be in path {SpisumNames.Paths.EvidenceDocumentsForProcessingForSignature(identityUser.RequestGroup)} or " +
$"{SpisumNames.Paths.EvidenceFilesDocumentsForProcessingForSignature(identityUser.RequestGroup)}.");
});
}
public FileDocumentAddValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId);
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
.WithName(x => "Group")
.WithMessage($"User isn't member of group {identityUser.RequestGroup}.");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.File)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.File}");
});
}
private void CacheNodeTypes(Assembly assm)
{
foreach(Type t in assm.GetTypes())
{
DataNodeAttribute dna = (DataNodeAttribute)Helper.CheckType(t, typeof(DataNodeAttribute), typeof(IDataNode));
if(dna == null)
{
continue;
}
NodeEntry ne = new NodeEntry();
ne.Type = t;
ne.Attribute = dna;
m_Nodes[dna.Name] = ne;
}
}
static PrimitiveManager DecodePrimitivesWeighted(NodeEntry n, GeometryEntry geo, SkinEntry skin, SceneEntry scene, InfluenceManager infManager, ref string Error)
{
PrimitiveManager manager = DecodePrimitives(n._matrix, geo);
MDL0BoneNode[] boneList;
MDL0BoneNode bone = null;
int boneCount;
string[] jointStrings = null;
byte* pCmd = stackalloc byte[4];
int cmdCount = skin._weightInputs.Count;
float weight = 0;
float* pWeights = null;
Vector3* pVert = null, pNorms = null;
ushort* pVInd = (ushort*)manager._indices.Address;
List<Vertex3> vertList = new List<Vertex3>(skin._weightCount);
Matrix* pMatrix = null;
UnsafeBuffer remap = new UnsafeBuffer(skin._weightCount * 2);
ushort* pRemap = (ushort*)remap.Address;
pNorms = (Vector3*)manager._faceData[1].Address;
manager._vertices = vertList;
//Find vertex source
foreach (SourceEntry s in geo._sources)
if (s._id == geo._verticesInput._source)
{
pVert = (Vector3*)((UnsafeBuffer)s._arrayData).Address;
break;
}
//Find joint source
foreach (InputEntry inp in skin._jointInputs)
if (inp._semantic == SemanticType.JOINT)
{
foreach (SourceEntry src in skin._sources)
if (src._id == inp._source)
{
jointStrings = src._arrayData as string[];
break;
}
}
else if (inp._semantic == SemanticType.INV_BIND_MATRIX)
{
foreach (SourceEntry src in skin._sources)
if (src._id == inp._source)
{
pMatrix = (Matrix*)((UnsafeBuffer)src._arrayData).Address;
break;
}
}
Error = "There was a problem creating the list of bones for geometry entry " + geo._name;
//Populate bone list
boneCount = jointStrings.Length;
boneList = new MDL0BoneNode[boneCount];
for (int i = 0; i < boneCount; i++)
boneList[i] = scene.FindNode(jointStrings[i])._node as MDL0BoneNode;
//Build command list
foreach (InputEntry inp in skin._weightInputs)
{
switch (inp._semantic)
{
case SemanticType.JOINT:
pCmd[inp._offset] = 1;
break;
case SemanticType.WEIGHT:
pCmd[inp._offset] = 2;
//Get weight source
foreach (SourceEntry src in skin._sources)
if (src._id == inp._source)
{
pWeights = (float*)((UnsafeBuffer)src._arrayData).Address;
break;
}
break;
default:
pCmd[inp._offset] = 0;
break;
}
}
Error = "There was a problem creating vertex influences for geometry entry " + geo._name;
//Build vertex list and remap table
for (int i = 0; i < skin._weightCount; i++)
{
//Create influence
int iCount = skin._weights[i].Length / cmdCount;
Influence inf = new Influence(/*iCount*/);
fixed (int* p = skin._weights[i])
{
int* iPtr = p;
for (int x = 0; x < iCount; x++)
{
for (int z = 0; z < cmdCount; z++, iPtr++)
if (pCmd[z] == 1)
bone = boneList[*iPtr];
else if (pCmd[z] == 2)
weight = pWeights[*iPtr];
inf._weights.Add(new BoneWeight(bone, weight));
}
}
inf.CalcMatrix();
Error = "There was a problem creating a vertex from the geometry entry " + geo._name + ".\nMake sure that all the vertices are weighted properly.";
Vertex3 v;
if (inf._weights.Count > 1)
{
//Match with manager
inf = infManager.FindOrCreate(inf, true);
v = new Vertex3(n._matrix * skin._bindMatrix * pVert[i], inf); //World position
}
else
{
bone = inf._weights[0].Bone;
v = new Vertex3(n._matrix * bone._inverseBindMatrix * skin._bindMatrix * pVert[i], bone); //Local position
}
ushort index = 0;
while (index < vertList.Count)
{
if (v.Equals(vertList[index])) break;
index++;
}
if (index == vertList.Count)
vertList.Add(v);
pRemap[i] = index;
}
Error = "There was a problem fixing normal rotations for geometry entry " + geo._name;
//Remap vertex indices and fix normals
for (int i = 0; i < manager._pointCount; i++, pVInd++)
{
*pVInd = pRemap[*pVInd];
Vertex3 v = null;
if (*pVInd < vertList.Count)
v = vertList[*pVInd];
if (v != null && v._matrixNode != null)
if (v._matrixNode.Weights.Count > 1)
pNorms[i] = skin._bindMatrix.GetRotationMatrix() * pNorms[i];
else
pNorms[i] = skin._bindMatrix.GetRotationMatrix() * v._matrixNode.Weights[0].Bone._inverseBindMatrix.GetRotationMatrix() * pNorms[i];
}
remap.Dispose();
return manager;
}
static PrimitiveManager DecodePrimitivesUnweighted(NodeEntry n, GeometryEntry geo)
{
PrimitiveManager manager = DecodePrimitives(n._matrix, geo);
Vector3* pVert = null;
ushort* pVInd = (ushort*)manager._indices.Address;
int vCount = 0;
List<Vertex3> vertList = new List<Vertex3>(manager._pointCount);
manager._vertices = vertList;
//Find vertex source
foreach (SourceEntry s in geo._sources)
if (s._id == geo._verticesInput._source)
{
UnsafeBuffer b = s._arrayData as UnsafeBuffer;
pVert = (Vector3*)b.Address;
vCount = b.Length / 12;
break;
}
UnsafeBuffer remap = new UnsafeBuffer(vCount * 2);
ushort* pRemap = (ushort*)remap.Address;
//Create remap table
for (int i = 0; i < vCount; i++)
{
//Create Vertex and look for match
Vertex3 v = new Vertex3(n._matrix * pVert[i]);
int index = 0;
while (index < vertList.Count)
{
if (v.Equals(vertList[index]))
break;
index++;
}
if (index == vertList.Count)
vertList.Add(v);
pRemap[i] = (ushort)index;
}
//Remap vertex indices
for (int i = 0; i < manager._pointCount; i++, pVInd++)
*pVInd = pRemap[*pVInd];
remap.Dispose();
return manager;
}
private void CacheNodeTypes(Assembly assm)
{
foreach(Type t in assm.GetTypes())
{
foreach (DataNodeAttribute dna in t.GetCustomAttributes(typeof(DataNodeAttribute), true))
{
NodeEntry ne = new NodeEntry();
ne.Type = t;
ne.Attribute = dna;
m_Nodes[dna.Name] = ne;
}
}
}
private void EnumNode(NodeEntry node, ResourceNode parent, SceneEntry scene, MDL0Node model, DecoderShell shell)
{
MDL0BoneNode bone = null;
Influence inf = null;
if (node._type == NodeType.JOINT)
{
Error = "There was a problem creating a new bone.";
bone = new MDL0BoneNode();
bone._name = node._name != null ? node._name : node._id;
bone._bindState = node._transform;
node._node = bone;
parent._children.Add(bone);
bone._parent = parent;
bone.RecalcBindState();
bone.CalcFlags();
foreach (NodeEntry e in node._children)
EnumNode(e, bone, scene, model, shell);
inf = new Influence(bone);
model._influences._influences.Add(inf);
}
else
foreach (NodeEntry e in node._children)
EnumNode(e, parent, scene, model, shell);
foreach (InstanceEntry inst in node._instances)
{
if (inst._type == InstanceType.Controller)
{
foreach (SkinEntry skin in shell._skins)
if (skin._id == inst._url)
{
foreach (GeometryEntry g in shell._geometry)
if (g._id == skin._skinSource)
{
Error = @"
There was a problem decoding weighted primitives for the object " + (node._name != null ? node._name : node._id) +
".\nOne or more vertices may not be weighted correctly.";
Say("Decoding weighted primitives for " + (g._name != null ? g._name : g._id) + "...");
CreateObject(inst, node, parent, DecodePrimitivesWeighted(node, g, skin, scene, model._influences, ref Error), model, shell);
break;
}
break;
}
}
else if (inst._type == InstanceType.Geometry)
{
foreach (GeometryEntry g in shell._geometry)
if (g._id == inst._url)
{
Error = "There was a problem decoding unweighted primitives for the object " + (node._name != null ? node._name : node._id) + ".";
Say("Decoding unweighted primitives for " + (g._name != null ? g._name : g._id) + "...");
CreateObject(inst, node, parent, DecodePrimitivesUnweighted(node, g), model, shell);
break;
}
}
else
{
foreach (NodeEntry e in shell._nodes)
if (e._id == inst._url)
EnumNode(e, parent, scene, model, shell);
}
}
}
public static int Compare(NodeEntry n1, NodeEntry n2)
{
if ((n1._type == NodeType.NODE || n1._type == NodeType.NONE) && n2._type == NodeType.JOINT)
return 1;
if (n1._type == NodeType.JOINT && (n2._type == NodeType.NODE || n2._type == NodeType.NONE))
return -1;
return 0;
}
internal static NodeEntry FindNodeInternal(string name, NodeEntry node)
{
NodeEntry e;
if (node._name == name || node._sid == name || node._id == name)
return node;
foreach (NodeEntry n in node._children)
if ((e = FindNodeInternal(name, n)) != null)
return e;
return null;
}
private NodeEntry ParseNode()
{
NodeEntry node = new NodeEntry();
while (_reader.ReadAttribute())
if (_reader.Name.Equals("id", true))
node._id = (string)_reader.Value;
else if (_reader.Name.Equals("name", true))
node._name = (string)_reader.Value;
else if (_reader.Name.Equals("sid", true))
node._sid = (string)_reader.Value;
else if (_reader.Name.Equals("type", true))
node._type = (NodeType)Enum.Parse(typeof(NodeType), (string)_reader.Value, true);
Matrix m = Matrix.Identity;
//if (node._type != NodeType.JOINT)
// node._type = NodeType.JOINT;
while (_reader.BeginElement())
{
if (_reader.Name.Equals("matrix", true))
m *= ParseMatrix();
else if (_reader.Name.Equals("rotate", true))
{
Vector4 v = ParseVec4();
m *= Matrix.RotationMatrix(v._x * v._w, v._y * v._w, v._z * v._w);
}
else if (_reader.Name.Equals("scale", true))
m.Scale(ParseVec3());
else if (_reader.Name.Equals("translate", true))
m.Translate(ParseVec3());
else if (_reader.Name.Equals("node", true))
node._children.Add(ParseNode());
else if (_reader.Name.Equals("instance_controller", true))
node._instances.Add(ParseInstance(InstanceType.Controller));
else if (_reader.Name.Equals("instance_geometry", true))
node._instances.Add(ParseInstance(InstanceType.Geometry));
else if (_reader.Name.Equals("instance_node", true))
node._instances.Add(ParseInstance(InstanceType.Node));
_reader.EndElement();
}
node._transform = (node._matrix = m).Derive();
return node;
}
private void CreateObject(InstanceEntry inst, NodeEntry node, ResourceNode parent, PrimitiveManager manager, MDL0Node model, DecoderShell shell)
{
if (manager != null)
{
Error = "There was a problem creating a new object for " + (node._name != null ? node._name : node._id);
int i = 0;
foreach (Vertex3 v in manager._vertices)
v._index = i++;
MDL0ObjectNode poly = new MDL0ObjectNode() { _manager = manager };
poly._manager._polygon = poly;
poly._name = node._name != null ? node._name : node._id;
//Attach single-bind
if (parent != null && parent is MDL0BoneNode)
poly.MatrixNode = (MDL0BoneNode)parent;
//Attach material
if (inst._material != null)
foreach (MaterialEntry mat in shell._materials)
if (mat._id == inst._material._target)
{
(poly._opaMaterial = (mat._node as MDL0MaterialNode))._objects.Add(poly);
break;
}
model._numFaces += poly._numFaces = manager._faceCount = manager._pointCount / 3;
model._numFacepoints += poly._numFacepoints = manager._pointCount;
poly._parent = model._objGroup;
model._objList.Add(poly);
}
}
