private static void iterScreenPopup(NodeHandler handler, ScreenPopupComposition popups)
{
foreach (Siemens.Engineering.Hmi.Screen.ScreenPopup popup in popups)
{
HandleScreenPopup(handler, popup);
}
}
private static void iterScreenTemplate(NodeHandler handler, ScreenTemplateComposition templates)
{
foreach (Siemens.Engineering.Hmi.Screen.ScreenTemplate template in templates)
{
HandleScreenTemplate(handler, template);
}
}
private static void iterTypeFolder(NodeHandler handler, PlcTypeUserGroupComposition folders)
{
foreach (PlcTypeUserGroup folder in folders)
{
HandleTypeFolder(handler, folder);
}
}
private static void iterType(NodeHandler handler, PlcTypeComposition types)
{
foreach (PlcType type in types)
{
HandleType(handler, type);
}
}
private static void iterScreen(NodeHandler handler, ScreenComposition screens)
{
foreach (Siemens.Engineering.Hmi.Screen.Screen screen in screens)
{
HandleScreen(handler, screen);
}
}
public void UseNode10ForNodeHandlerEnvVarSet()
{
try
{
Environment.SetEnvironmentVariable("AGENT_USE_NODE10", "true");
using (TestHostContext thc = CreateTestHostContext())
{
thc.SetSingleton(new WorkerCommandManager() as IWorkerCommandManager);
thc.SetSingleton(new ExtensionManager() as IExtensionManager);
NodeHandler nodeHandler = new NodeHandler();
nodeHandler.Initialize(thc);
nodeHandler.ExecutionContext = CreateTestExecutionContext(thc);
nodeHandler.Data = new Node10HandlerData();
string actualLocation = nodeHandler.GetNodeLocation();
string expectedLocation = Path.Combine(thc.GetDirectory(WellKnownDirectory.Externals),
"node10",
"bin",
$"node{IOUtil.ExeExtension}");
Assert.Equal(expectedLocation, actualLocation);
}
}
finally
{
Environment.SetEnvironmentVariable("AGENT_USE_NODE10", null);
}
}
private static void iterDataBlock(NodeHandler handler, PlcBlockComposition blocks)
{
foreach (PlcBlock block in blocks)
{
HandleDataBlock(handler, block);
}
}
private static void iterDeviceFolder(NodeHandler handler, DeviceUserFolderAggregation folders)
{
foreach (DeviceUserFolder f in folders)
{
handleDeviceFolder(handler, f);
}
}
private static void iterBlockFolder(NodeHandler handler, PlcBlockUserGroupComposition folders)
{
foreach (PlcBlockUserGroup folder in folders)
{
HandleBlockFolder(handler, folder);
}
}
public static XmlAuthorDao AuthorDao(DocumentHolder forAuthors, DocumentHolder forBooks)
{
var authorDao = AuthorDao(forAuthors);
var bookDao = BookDao(forBooks);
authorDao.BookDao = bookDao;
bookDao.AuthorDao = authorDao;
authorDao.Parser = new AuthorProxyNodeParser <Author>()
{
BookDao = bookDao
};
bookDao.Parser = new BookProxyNodeParser <Book>()
{
AuthorDao = authorDao
};
var nodeHandler = NodeHandler.GetNodeHandlerFor(forBooks, forAuthors);
authorDao.NodeHandler = nodeHandler;
bookDao.NodeHandler = nodeHandler;
return(authorDao);
}
public static void Handle(NodeHandler handler, TiaPortal tia)
{
foreach (Project p in tia.Projects)
{
handleProject(handler, p);
}
}
private static void iterBlockFolder(NodeHandler handler, ProgramblockUserFolderAggregation folders)
{
foreach (ProgramblockUserFolder folder in folders)
{
handleBlockFolder(handler, folder);
}
}
// Start is called before the first frame update
void Start()
{
obstacleHandler.Init(obstacleDefiner);
obstacleHandler.CreateAndRenderObstacles(obstacleDefiner.GetObstaclePoints());
nodeHandler = new GridHandler();
nodeHandler.CreateNodes();
}
public void Update(Book book, ISet <int> updatedAuthors, ISet <int> updatedBooks)
{
if (updatedBooks.Contains(book.Id))
{
return;
}
Update(book);
updatedBooks.Add(book.Id);
var bookIsProxy = book is BookProxy;
var authorsAreFetched = bookIsProxy && ((BookProxy)book).AuthorsAreFetchedOrSet;
if ((bookIsProxy && !authorsAreFetched) || (!bookIsProxy && book.Authors.Count == 0))
{
return;
}
var actualAuthors = new HashSet <int>();
foreach (var author in book.Authors)
{
if (!updatedAuthors.Contains(author.Id))
{
AuthorDao.Save(author, SaveOption.UPDATE_IF_EXIST,
updatedAuthors, updatedBooks);
}
actualAuthors.Add(author.Id);
}
var fetchedAuthors = new HashSet <int>(GetAuthorsIdByBook(book));
if (actualAuthors.Count == fetchedAuthors.Count)
{
return;
}
if (actualAuthors.Count > fetchedAuthors.Count)
{
actualAuthors.ExceptWith(fetchedAuthors);
foreach (var authorId in actualAuthors)
{
NodeHandler.AddAuthorToBook(book.Id, authorId);
}
}
else
{
fetchedAuthors.ExceptWith(actualAuthors);
foreach (var authorId in fetchedAuthors)
{
NodeHandler.RemoveAuthorFromBook(book.Id, authorId);
NodeHandler.RemoveBookFromAuthor(book.Id, authorId);
}
}
DocumentHolder.Document.Save(DocumentHolder.Path);
}
public static void Handle(NodeHandler handler, TiaPortal tia)
{
foreach (Project p in tia.Projects)
{
handleProject(handler, p);
}
}
private static bool _ForEach
(
NodeHandler handler,
Node node)
{
bool result = true;
if (node != null)
{
result = _ForEach
(
handler,
node.LeftChild);
if (result)
{
result = handler(node);
}
if (result)
{
result = _ForEach
(
handler,
node.RightChild);
}
}
return(result);
}
/// <summary>
/// Executes delegate for this node and each child node.
/// </summary>
/// <param name="handler"></param>
/// <returns></returns>
public bool ForEach(NodeHandler handler)
{
return(_ForEach
(
handler,
this));
}
public void SetText(NodeHandler node)
{
bias.text = node.bias.ToString("0.00000");
error.text = node.error.ToString("0.00000");
errorDelta.text = node.errorDelta.ToString("0.00000");
output.text = node.output.ToString("0.00000");
}
private static void IterDeviceFolder(NodeHandler handler, DeviceUserGroupComposition folders)
{
foreach (DeviceUserGroup f in folders)
{
HandleDeviceFolder(handler, f);
}
}
private static void IterDevice(NodeHandler handler, DeviceComposition devices)
{
foreach (Device d in devices)
{
HandleDevice(handler, d);
}
}
private static void iterDevice(NodeHandler handler, DeviceAggregation devices)
{
foreach (Device d in devices)
{
handleDevice(handler, d);
}
}
public void Delete(int id)
{
if (id <= 0)
{
return;
}
var xDoc = DocumentHolder.Document;
var root = xDoc.DocumentElement;
var book = FindById(id);
if (book is null)
{
return;
}
foreach (var author in book.Authors)
{
NodeHandler.RemoveBookFromAuthor(book.Id, author.Id);
}
var bookNode = root.SelectSingleNode("book[@id ='" + id + "']");
root.RemoveChild(bookNode);
cache.TryRemove(id, out _);
xDoc.Save(DocumentHolder.Path);
}
private static void iterDeviceItem(NodeHandler handler, IDeviceItemAggregation items)
{
foreach (IDeviceItem item in items)
{
handleDeviceItem(handler, item);
}
}
public void UseNode10ForNode10HandlerHostContextVarUnset()
{
using (TestHostContext thc = CreateTestHostContext())
{
thc.SetSingleton(new WorkerCommandManager() as IWorkerCommandManager);
thc.SetSingleton(new ExtensionManager() as IExtensionManager);
var variables = new Dictionary <string, VariableValue>();
// Explicitly set 'AGENT_USE_NODE10' feature flag to false
variables.Add("AGENT_USE_NODE10", new VariableValue("false"));
NodeHandler nodeHandler = new NodeHandler();
nodeHandler.Initialize(thc);
nodeHandler.ExecutionContext = CreateTestExecutionContext(thc, variables);
nodeHandler.Data = new Node10HandlerData();
// Node10 handler is unaffected by the 'AGENT_USE_NODE10' feature flag, so folder name should be 'node10'
string actualLocation = nodeHandler.GetNodeLocation();
string expectedLocation = Path.Combine(thc.GetDirectory(WellKnownDirectory.Externals),
"node10",
"bin",
$"node{IOUtil.ExeExtension}");
Assert.Equal(expectedLocation, actualLocation);
}
}
private static void IterDeviceItem(NodeHandler handler, DeviceItemComposition items)
{
foreach (DeviceItem item in items)
{
handleDeviceItem(handler, item);
}
}
public void UseNode10ForNodeHandlerHostContextVarSet()
{
using (TestHostContext thc = CreateTestHostContext())
{
thc.SetSingleton(new WorkerCommandManager() as IWorkerCommandManager);
thc.SetSingleton(new ExtensionManager() as IExtensionManager);
var variables = new Dictionary <string, VariableValue>();
variables.Add("AGENT_USE_NODE10", new VariableValue("true"));
NodeHandler nodeHandler = new NodeHandler();
nodeHandler.Initialize(thc);
nodeHandler.ExecutionContext = CreateTestExecutionContext(thc, variables);
nodeHandler.Data = new NodeHandlerData();
string actualLocation = nodeHandler.GetNodeLocation();
string expectedLocation = Path.Combine(thc.GetDirectory(WellKnownDirectory.Externals),
"node10",
"bin",
$"node{IOUtil.ExeExtension}");
Assert.Equal(expectedLocation, actualLocation);
}
}
private static void iterDataBlock(NodeHandler handler, IBlockAggregation blocks)
{
foreach (IBlock block in blocks)
{
handleDataBlock(handler, block);
}
}
private static void iterScreenFolder(NodeHandler handler, ScreenUserFolderComposition folders)
{
Console.WriteLine("iterScreenFolder");
foreach (ScreenFolder folder in folders)
{
handleScreenFolder(handler, folder);
}
}
private static void handleDevice(NodeHandler handler, Device device)
{
NodeHandler child_handler = handler.Enter(device, device.Name);
if (child_handler != null)
{
iterDeviceItem(child_handler, device.DeviceItems);
}
handler.Exit(device);
}
private static void handleBlockFolder(NodeHandler handler, ProgramblockUserFolder folder)
{
NodeHandler child_handler = handler.Enter(folder.Blocks, folder.Name);
if (child_handler != null) {
iterDataBlock(child_handler, folder.Blocks);
iterBlockFolder(child_handler, folder.Folders);
}
handler.Exit(folder.Blocks);
}
public void Execute(ProcessNode processNode, ProcessNode previousNode)
{
NodeHandler = ProcessInstance.NodeHandlers[NodeType];
if (processNode.InputParameters == null)
{
processNode.InputParameters = ProcessInstance.InputParameters;
}
Task = new Task(() => NodeHandler.Execute(processNode, previousNode));
Task.Start();
}
private static void handleDevice(NodeHandler handler, Device device)
{
NodeHandler child_handler = handler.Enter(device, device.Name);
if (child_handler != null)
{
iterDeviceItem(child_handler, device.DeviceItems);
}
handler.Exit(device);
}
private static void handleBlockFolder(NodeHandler handler, ProgramblockUserFolder folder)
{
NodeHandler child_handler = handler.Enter(folder.Blocks, folder.Name);
if (child_handler != null)
{
iterDataBlock(child_handler, folder.Blocks);
iterBlockFolder(child_handler, folder.Folders);
}
handler.Exit(folder.Blocks);
}
private static void handleDeviceFolder(NodeHandler handler, DeviceUserFolder folder)
{
TreeNode node = new TreeNode(folder.Name);
node.Tag = folder;
NodeHandler child_handler = handler.Enter(folder, folder.Name);
if (child_handler != null)
{
iterDeviceFolder(child_handler, folder.Folders);
iterDevice(child_handler, folder.Devices);
}
handler.Exit(folder);
}
private static void handleDeviceItem(NodeHandler handler, IDeviceItem item)
{
NodeHandler child_handler = handler.Enter(item, item.Name);
if (child_handler != null)
{
ControllerTarget controller = item as ControllerTarget;
if (controller != null)
{
NodeHandler block_handler = child_handler.Enter(controller.ProgramblockFolder.Blocks, "Blocks");
if (block_handler != null)
{
iterDataBlock(block_handler, controller.ProgramblockFolder.Blocks);
iterBlockFolder(block_handler, controller.ProgramblockFolder.Folders);
}
child_handler.Exit(controller.ProgramblockFolder.Blocks);
}
iterDeviceItem(child_handler, item.DeviceItems);
}
handler.Exit(item);
}
private static void iterDevice(NodeHandler handler, DeviceAggregation devices)
{
foreach (Device d in devices)
{
handleDevice(handler, d);
}
}
/// <summary>
/// Registers the specified node <paramref name="handler"/>, for the specified <paramref name="nodeType"/>,
/// <paramref name="nodeName"/> and <paramref name="nodeNamespace"/>.
/// </summary>
/// <param name="nodeType">The type of the node for which the handler is being registered.</param>
/// <param name="nodeName">The name of the node for which the handler is being registered.</param>
/// <param name="nodeNamespace">The namespace of the node for which the handler is being registered.</param>
/// <param name="handler">The method that will will handle the node.</param>
public static void RegisterNodeHandler(XmlNodeType nodeType, string nodeName, string nodeNamespace, NodeHandler handler)
{
Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(nodeName));
Contract.Requires<ArgumentNullException>(handler != null);
string qualifiedName = NodeEvaluator.QualifyName(nodeType, nodeName, nodeNamespace);
if (nodeHandlers.ContainsKey(qualifiedName))
{
if (nodeHandlers[qualifiedName] == handler)
return;
log.WarnFormat("Replacing existing handler '{0}' for element '{1}' with new handler '{2}'",
Util.GetMethodSignature(nodeHandlers[qualifiedName].Method),
qualifiedName,
Util.GetMethodSignature(handler.Method));
}
nodeHandlers[qualifiedName] = handler;
}
private static void handleProject(NodeHandler handler, Project proj)
{
TreeNode node = new TreeNode(proj.Path);
node.Tag = proj;
NodeHandler child_handler = handler.Enter(proj, proj.Path);
if (child_handler != null)
{
iterDeviceFolder(child_handler, proj.DeviceFolders);
iterDevice(child_handler, proj.Devices);
}
handler.Exit(proj);
}
private static void iterBlockFolder(NodeHandler handler, ProgramblockUserFolderAggregation folders)
{
foreach (ProgramblockUserFolder folder in folders)
{
handleBlockFolder(handler, folder);
}
}
private static void iterDataBlock(NodeHandler handler, IBlockAggregation blocks)
{
foreach (IBlock block in blocks)
{
handleDataBlock(handler, block);
}
}
private static void iterDeviceFolder(NodeHandler handler, DeviceUserFolderAggregation folders)
{
foreach (DeviceUserFolder f in folders)
{
handleDeviceFolder(handler, f);
}
}
private static void iterDeviceItem(NodeHandler handler, IDeviceItemAggregation items)
{
foreach (IDeviceItem item in items)
{
handleDeviceItem(handler, item);
}
}
private static void handleDataBlock(NodeHandler handler, IBlock block)
{
handler.Enter(block, block.Name);
handler.Exit(block);
}