public void Save(string filename)
{
var document = new XDocument();
var root = new XElement(ConfigTag);
document.Add(root);
root.Add(new XElement(DatabaseServerTag, DatabaseServer));
root.Add(new XElement(DatabasePortTag, DatabasePort));
root.Add(new XElement(DatabaseNameTag, DatabaseName));
root.Add(new XElement(DatabaseUsernameTag, DatabaseUsername));
root.Add(new XElement(DatabasePasswordTag, DatabasePassword));
root.Add(new XElement(AdminMailAddressTag, AdminMailAddress));
root.Add(new XElement(SystemMailAddressTag, SystemMailAddress));
root.Add(new XElement(SystemMailGpgKeyIdTag, SystemMailGpgKeyId));
root.Add(new XElement(SystemMailGpgKeyPassphraseTag, SystemMailGpgKeyPassphrase));
root.Add(new XElement(MailServerHostTag, MailServerHost));
root.Add(new XElement(MailServerPortTag, MailServerPort));
root.Add(new XElement(MailAccountNameTag, MailAccountName));
root.Add(new XElement(MailAccountPasswordTag, MailAccountPassword));
root.Add(new XElement(WebSiteAddressTag, WebSiteAddress));
root.Add(new XElement(GpgHomedirTag, GpgHomedir));
root.Add(new XElement(PingenApiTokenTag, PingenApiToken));
root.Add(new XElement(SiteNameTag, SiteName));
root.Add(new XElement(LinkKeyTag, LinkKey.ToHexString()));
root.Add(new XElement(OAuth2AuthorizationUrlTag, OAuth2AuthorizationUrl));
root.Add(new XElement(OAuth2TokenUrlTag, OAuth2TokenUrl));
root.Add(new XElement(OAuth2ApiUrlTag, OAuth2ApiUrl));
root.Add(new XElement(OAuth2ClientIdTag, OAuth2ClientId));
root.Add(new XElement(OAuth2ClientSecretTag, OAuth2ClientSecret));
document.Save(filename);
}
private Rule applyRule(RuleKey ruleKey, LinkKey linkKey, ElementScript firstElement, ElementScript secondElement)
{
Rule rule;
if (rules.TryGetValue(ruleKey, out rule))
{
// there is a rule between these two types
if (rule.hasLink)
{
Debug.Log("Adding link for rule " + rule.type + " between " + firstElement.name + " and " + secondElement.name);
addLink(rule.type, linkKey, firstElement, secondElement);
}
else
{
// remove any link between these two objects
Debug.Log("Removing link for rule " + rule.type + " between " + firstElement.name + " and " + secondElement.name);
removeLink(linkKey, firstElement, secondElement);
}
firstElement.Type = rule.firstTypeFinal;
secondElement.Type = rule.secondTypeFinal;
UpdateLinks(linkKey);
}
return(rule);
}
public AesEncrypter(IOptions <LinkKey> options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
this.Key = options.Value;
buildKey();
}
private Link addLink(string ruleType, LinkKey linkKey, ElementScript firstElement, ElementScript secondElement)
{
Link link;
// if link already exists update it with the new rule type
if (links.TryGetValue(linkKey, out link))
{
if (link.type != ruleType)
{
activeRules[link.type].Remove(linkKey);
link.type = ruleType;
activeRules[ruleType].Add(linkKey);
}
return(link);
}
link = new Link(ruleType, firstElement, secondElement);
links[linkKey] = link;
HashSet <LinkKey> linksForRule;
if (!activeRules.TryGetValue(ruleType, out linksForRule))
{
linksForRule = new HashSet <LinkKey>();
activeRules.Add(ruleType, linksForRule);
}
linksForRule.Add(linkKey);
HashSet <LinkKey> neighborsFirst;
if (!elementLinks.TryGetValue(firstElement.name, out neighborsFirst))
{
neighborsFirst = new HashSet <LinkKey>();
elementLinks.Add(firstElement.name, neighborsFirst);
}
neighborsFirst.Add(linkKey);
HashSet <LinkKey> neighborsSecond;
if (!elementLinks.TryGetValue(secondElement.name, out neighborsSecond))
{
neighborsSecond = new HashSet <LinkKey>();
elementLinks.Add(secondElement.name, neighborsSecond);
}
neighborsSecond.Add(linkKey);
return(link);
}
private void removeLink(LinkKey linkKey, ElementScript firstElement, ElementScript secondElement)
{
Link link;
if (links.TryGetValue(linkKey, out link))
{
links.Remove(linkKey);
link.Remove();
}
elementLinks[firstElement.name].Remove(linkKey);
elementLinks[secondElement.name].Remove(linkKey);
}
public void AddCollision(ElementScript firstElement, ElementScript secondElement)
{
// see if we already have a link between these two objects
LinkKey linkKey = new LinkKey(firstElement.name, secondElement.name);
if (!links.ContainsKey(linkKey))
{
Rule rule;
if ((rule = applyRule(new RuleKey(firstElement.Type, secondElement.Type), linkKey, firstElement, secondElement)) == null)
{
rule = applyRule(new RuleKey(secondElement.Type, firstElement.Type), linkKey, secondElement, firstElement);
}
}
}
private void putNodeAndLink(Dictionary <Element, AddtionalNodeInfomation> nodes, Dictionary <LinkKey, AddtionalLinkInfomation> links, Element element, int distance)
{
//自分自身をノードリストに追加します。
//結果変数はHashSetなので重複を考慮しなくても本来は問題ないですが、重複した場合後勝ちとなるため、先勝ちとなるよう存在チェックを行います。
if (!nodes.ContainsKey(element))
{
nodes.Add(element, new AddtionalNodeInfomation(distance));
}
//依存する要素を取得し結果変数に格納します。
//結果変数はHashSetなので重複を考慮しなくても本来は問題ないですが、重複した場合後勝ちとなるため、先勝ちとなるよう存在チェックを行います。
List <Dependency> dependencies = element.getDependency();
foreach (Dependency dependency in dependencies)
{
if (!nodes.ContainsKey(dependency.dependencyElement))
{
nodes.Add(dependency.dependencyElement, new AddtionalNodeInfomation(distance));
}
LinkKey linkKey = new LinkKey(element, dependency.dependencyElement);
if (!links.ContainsKey(linkKey))
{
links.Add(linkKey, new AddtionalLinkInfomation(dependency, distance, this.getDrection(dependency)));
}
}
//依存される要素を取得し結果変数に格納します。
//結果変数はHashSetなので重複を考慮しなくても本来は問題ないですが、重複した場合後勝ちとなるため、先勝ちとなるよう存在チェックを行います。
List <Dependency> dependenciesDependOnMe = element.getDependencyDependOnMe();
foreach (Dependency dependencyDependOnMe in dependenciesDependOnMe)
{
if (!nodes.ContainsKey(dependencyDependOnMe.element))
{
nodes.Add(dependencyDependOnMe.element, new AddtionalNodeInfomation(distance));
}
LinkKey linkKey = new LinkKey(dependencyDependOnMe.element, element);
if (!links.ContainsKey(linkKey))
{
links.Add(linkKey, new AddtionalLinkInfomation(dependencyDependOnMe, distance, this.getDrection(dependencyDependOnMe)));
}
}
}
private void UpdateLinks(LinkKey originalLinkKey)
{
Queue <string> elementsToCheck = new Queue <string>();
HashSet <string> processedElements = new HashSet <string>();
elementsToCheck.Enqueue(originalLinkKey.first);
elementsToCheck.Enqueue(originalLinkKey.second);
processedElements.Add(originalLinkKey.first);
processedElements.Add(originalLinkKey.second);
while (elementsToCheck.Count > 0)
{
string elementName = elementsToCheck.Dequeue();
HashSet <LinkKey> neighborsOriginal;
if (elementLinks.TryGetValue(elementName, out neighborsOriginal))
{
// see if there is a rule between the neighbor's type and the new element's type;
ElementScript element = elements[elementName];
HashSet <LinkKey> neighbors = new HashSet <LinkKey>(neighborsOriginal);
foreach (LinkKey linkKey in neighbors)
{
string otherElementName = linkKey.GetOther(elementName);
if (processedElements.Contains(otherElementName))
{
continue;
}
ElementScript otherElement = elements[otherElementName];
Debug.Log("Processing link between " + elementName + " and " + otherElementName);
Rule rule;
if (rules.TryGetValue(new RuleKey(element.Type, otherElement.Type), out rule))
{
// there is a rule between these two types
if (rule.hasLink)
{
addLink(rule.type, linkKey, element, otherElement);
}
else
{
// remove any link between these two objects
removeLink(linkKey, element, otherElement);
}
element.Type = rule.firstTypeFinal;
otherElement.Type = rule.secondTypeFinal;
elementsToCheck.Enqueue(otherElementName);
}
else if (rules.TryGetValue(new RuleKey(otherElement.Type, element.Type), out rule))
{
// there is a rule between these two types
if (rule.hasLink)
{
addLink(rule.type, linkKey, otherElement, element);
}
else
{
// remove any link between these two objects
removeLink(linkKey, element, otherElement);
}
otherElement.Type = rule.firstTypeFinal;
element.Type = rule.secondTypeFinal;
if (!processedElements.Contains(otherElementName))
{
elementsToCheck.Enqueue(otherElementName);
}
}
else
{
removeLink(linkKey, element, otherElement);
}
}
}
processedElements.Add(elementName);
}
}
public ActionResult <string> DataFlowInfomation([FromForm] string[] nodeStrings)
{
Dictionary <Element, AddtionalNodeInfomation> nodes = new Dictionary <Element, AddtionalNodeInfomation>();
Dictionary <LinkKey, AddtionalLinkInfomation> links = new Dictionary <LinkKey, AddtionalLinkInfomation>();
List <Element> groups = new List <Element>();
//1段階目の取得■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
for (int i = 0; i < nodeStrings.Length; i++)
{
//空文字の場合はスキップ
if (nodeStrings[i].Equals(""))
{
continue;
}
//rootノードの場合はスキップ
if (nodeStrings[i].Equals("root"))
{
continue;
}
Element element = Element.getElement(nodeStrings[i]);
this.putNodeAndLink(nodes, links, element, 1);
if (!element.isLeaf())
{
foreach (Element child in element.getChild())
{
this.putNodeAndLink(nodes, links, child, 1);
}
//昇格のためのgroupエレメントを配列に格納します。
//同一Groupの親－子－孫が候補の場合、格納するのは親Groupエレメントのみです。
bool isAdd = true;
Element unnecesarryGroup = null;
foreach (Element group in groups)
{
if (group.contain(element))
{
isAdd = false;
break;
}
if (element.contain(group))
{
unnecesarryGroup = group;
break;
}
}
if (isAdd)
{
groups.Add(element);
}
if (unnecesarryGroup != null)
{
groups.Remove(unnecesarryGroup);
}
}
}
//2段階目の取得■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//2段階目を取得する際に、ループを回すコレクションに対し要素追加を行うとConcurrentModificationExceptionが発生するためコピーします
Dictionary <Element, AddtionalNodeInfomation> nodes2 = new Dictionary <Element, AddtionalNodeInfomation>();
nodes2 = new Dictionary <Element, AddtionalNodeInfomation>(nodes);
//2段階目を取得します
foreach (KeyValuePair <Element, AddtionalNodeInfomation> nodeSet in nodes)
{
this.putNodeAndLink(nodes2, links, nodeSet.Key, 2);
}
//グループ化■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Dictionary <Element, AddtionalNodeInfomation> nodes3 = new Dictionary <Element, AddtionalNodeInfomation>();
Dictionary <LinkKey, AddtionalLinkInfomation> links3 = new Dictionary <LinkKey, AddtionalLinkInfomation>();
foreach (KeyValuePair <Element, AddtionalNodeInfomation> nodeSet in nodes2)
{
bool isGroupNode = false;
foreach (Element group in groups)
{
//グループ内のノード以外を対象とします
if (group.contain(nodeSet.Key.getId()))
{
isGroupNode = true;
break;
}
}
if (!isGroupNode)
{
nodes3.Add(nodeSet.Key, nodeSet.Value);
}
}
foreach (KeyValuePair <LinkKey, AddtionalLinkInfomation> linkSet in links)
{
bool isGroupLink = false;
bool isVirtual = false;
LinkKey linkKey = null;
Element source = linkSet.Key.getSource();
Element target = linkSet.Key.getTarget();
foreach (Element group in groups)
{
//グループ内のリンク以外を対象とします
if (group.contain(linkSet.Key.getSource()) && group.contain(linkSet.Key.getTarget()))
{
isGroupLink = true;
break;
}
else if (group.contain(linkSet.Key.getSource()))
{
//グループ内のノードはグループノードに昇格します（ソース側）
source = group;
isVirtual = true;
}
else if (group.contain(linkSet.Key.getTarget()))
{
//グループ内のノードはグループノードに昇格します（ターゲット側）
target = group;
isVirtual = true;
}
}
linkKey = new LinkKey(source, target);
if (!isGroupLink)
{
//昇格した結果、そのリンクがすでに存在していれば集約します。
if (links3.ContainsKey(linkKey))
{
AddtionalLinkInfomation val;
links3.TryGetValue(linkKey, out val);
this.summarizeLink(linkSet.Value, val, false);
}
else
{
linkSet.Value.isVirtual = isVirtual;
links3.Add(linkKey, linkSet.Value);
}
}
}
//逆向きリンクの集約■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Dictionary <LinkKey, AddtionalLinkInfomation> links4 = new Dictionary <LinkKey, AddtionalLinkInfomation>();
foreach (KeyValuePair <LinkKey, AddtionalLinkInfomation> linkSet3 in links3)
{
bool duplex = false;
foreach (KeyValuePair <LinkKey, AddtionalLinkInfomation> linkSet4 in links4)
{
//ソースとターゲットが同一ノードで逆向きとなっているリンクがあれば集約します
if (linkSet3.Key.getSource() == linkSet4.Key.getTarget() && linkSet3.Key.getTarget() == linkSet4.Key.getSource())
{
this.summarizeLink(linkSet3.Value, linkSet4.Value, true);
duplex = true;
break;
}
}
if (!duplex)
{
links4.Add(linkSet3.Key, linkSet3.Value);
}
}
var dataflow = new Dataflow();
foreach (KeyValuePair <Element, AddtionalNodeInfomation> element in nodes3)
{
var node = new Node2
{
parent = element.Key.getParent().getId(),
id = element.Key.getId(),
name = element.Key.getName(),
type = element.Key.getType(),
remark = element.Key.getRemark(),
svgFile = element.Key.getSvgFile() + ".svg",
visible = element.Value.getDistance() == 2 ? false : true,
size = element.Key.isLeaf() ? 32 : 64,
group = !element.Key.isLeaf(),
depth = element.Key.getParent().getId().Equals(Element.getRoot().getId()) ? 0 : element.Key.getParent().getId().Split('.').Length
};
dataflow.nodes.Add(node);
}
foreach (KeyValuePair <LinkKey, AddtionalLinkInfomation> linkSet in links4)
{
Dependency depndency = linkSet.Value.getDependency();
var link = new Link
{
source = linkSet.Key.getSource().getId(),
target = linkSet.Key.getTarget().getId(),
isCreate = depndency.dependencyTypeCreate,
isRead = depndency.dependencyTypeRead,
isUpdate = depndency.dependencyTypeUpdate,
isDelete = depndency.dependencyTypeDelete,
remark = depndency.remark,
io = linkSet.Value.getDirection().ToString(),
colorIndex = Convert.ToInt32(depndency.getDependencyType(), 2).ToString(),
visible = linkSet.Value.getDistance() == 2 ? false : true,
isVirtual = linkSet.Value.isVirtual
};
dataflow.links.Add(link);
}
return(JsonConvert.SerializeObject(dataflow));
}
