private void Adopt(Binding binding, string bindingUrl)
{
binding.parent.bindings.Remove(binding);
binding.parent = this;
bindings.Add(binding);
binding.bindingUrl = bindingUrl;
}
private void CreateControllersTreeFromBinding(ExplorerNode parent, Binding binding)
{
foreach (Bistro.Methods.Controller item in binding.Controllers)
{
new ControllerNode(parent, item.Type, ControllerNode.ControllerNodeType.None);
}
}
private Binding(Binding parent, string verb, string bindingUrl)
{
this.parent = parent;
engine = parent.engine;
this.verb = verb;
this.bindingUrl = bindingUrl;
fullBindingUrl = parent.fullBindingUrl + bindingUrl;
parent.bindings.Add(this);
}
internal void Validate(string parentUrl, Binding binding)
{
string fullUrl = parentUrl + bindingUrl;
binding.Bindings.ForEach(child =>
{
BindingTest test = null;
string lookup = (child.BindingUrl == child.FullBindingUrl) ? (child.Verb + " " + child.BindingUrl) : child.BindingUrl;
test.Validate(fullUrl, child);
});
SortedList<int, Controller> controllers = new SortedList<int,Controller>();
binding.Controllers.ForEach(controller => controllers.Add(controller.SeqNumber, controller));
for (int i = 0; i < this.controllers.Length && i < binding.Controllers.Count; i++)
this.controllers[i].Validate(fullUrl, controllers.Values[binding.Controllers.Count - i - 1]);
}
private void CreateMethodsTreeFromBinding(ExplorerNode parent, Binding binding)
{
foreach (Bistro.Methods.Binding item in binding.Bindings)
{
BindingNode newParent = new BindingNode(parent, item.Verb, item.BindingUrl);
if (item.Bindings.Count > 0)
{
CreateMethodsTreeFromBinding(new BindingNode(parent, item.Verb, item.BindingUrl), item);
}
if (item.Controllers.Count > 0)
{
CreateControllersTreeFromBinding(newParent, item);
}
}
}
public void Validate(string parentUrl, Binding binding)
{
string fullUrl = parentUrl + bindingUrl;
binding.Bindings.ForEach(child =>
{
BindingTest test;
string lookup = (child.BindingUrl == child.FullBindingUrl) ? (child.Verb + " " + child.BindingUrl) : child.BindingUrl;
Assert.IsTrue(children.TryGetValue(lookup, out test), "Binding " + fullUrl + " Unexpected binding " + child.BindingUrl);
test.Validate(fullUrl, child);
});
Assert.AreEqual(children.Count, binding.Bindings.Count, "Binding " + fullUrl + ": Invalid number of child bindings");
SortedList<int, Controller> controllers = new SortedList<int,Controller>();
binding.Controllers.ForEach(controller => controllers.Add(controller.SeqNumber, controller));
for (int i = 0; i < this.controllers.Length && i < binding.Controllers.Count; i++)
this.controllers[i].Validate(fullUrl, controllers.Values[binding.Controllers.Count - i - 1]);
Assert.AreEqual(this.controllers.Length, binding.Controllers.Count, "Binding " + fullUrl + ": Invalid number of controllers");
}
private void CreateControllersTreeFromBinding(ExplorerNode parent, Binding binding)
{
foreach (Bistro.Methods.Controller item in binding.Controllers)
{
ControllerNode parent1 = new ControllerNode(parent, item.Type, ControllerNode.ControllerNodeType.None);
if (parent1.Name.CompareTo("DataAccessControl")== 0){
new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Consumer);
new ResourceNode(parent1, "Resource2", ControllerNode.ControllerNodeType.Provider);
}
if (parent1.Name.CompareTo("AdDisplay") == 0)
{
new ResourceNode(parent1, "Resource3", ControllerNode.ControllerNodeType.Consumer);
new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Provider);
}
if (parent1.Name.CompareTo("AdUpdate") == 0)
{
new ResourceNode(parent1, "Resource5", ControllerNode.ControllerNodeType.Consumer);
new ResourceNode(parent1, "Resource1", ControllerNode.ControllerNodeType.Provider);
}
}
}
public BistroNode(ExplorerNode root, Binding binding)
: base(root, BISTRO_NODE_NAME, BINDERS_ICON, OPEN_FOLDER_ICON)
{
methods = new MethodsNode(this);
CreateMethodsTreeFromBinding(methods, binding);
}
public Controller(Binding binding, Controller source)
{
type = source.type;
this.binding = binding;
}
public Controller(Binding binding, ControllerType type, string methodUrl)
{
this.type = type;
this.binding = binding;
}
internal void Validate(Binding binding)
{
Validate("", binding);
}
public void Add(Binding binding) { dictionary.Add(buildKey(binding), binding); }
public void Validate(Binding root)
{
//TODO: Check whether right controllers are returned.
}
//internal void Register(Controller controller)
//{
// controllers.Add(controller);
// controller.Type.Register(controller);
// foreach (string resourceName in controller.Type.Provides)
// lookupResource(resourceName).AddProvider(controller.Type);
// foreach (string resourceName in controller.Type.Requires)
// lookupResource(resourceName).AddRequiredBy(controller.Type);
// foreach (string resourceName in controller.Type.DependsOn)
// lookupResource(resourceName).AddDependents(controller.Type);
//}
internal void Register(Binding binding,ControllerType ctrType, string methodUrl)
{
foreach (Controller ctr in controllers)
{
if (ctr.Type == ctrType)
return;
}
Controller controller = new Controller(binding, ctrType, methodUrl);
controllers.Add(controller);
ctrType.Register(controller);
foreach (string resourceName in controller.Type.Provides)
lookupResource(resourceName).AddProvider(controller.Type);
foreach (string resourceName in controller.Type.Requires)
lookupResource(resourceName).AddRequiredBy(controller.Type);
foreach (string resourceName in controller.Type.DependsOn)
lookupResource(resourceName).AddDependents(controller.Type);
}
/// <summary>
/// Matches method to binding
/// </summary>
/// <param name="binding"></param>
/// <returns></returns>
/// <remarks>method binding is always treated literally, while binding binding is
/// checked for wildcards</remarks>
private static bool Match(Binding method, Binding binding)
{
string verb = method.verb;
string methodUrl = method.fullBindingUrl;
string bindingVerb = binding.verb;
string bindingUrl = binding.fullBindingUrl;
if (verb != bindingVerb && bindingVerb != "*")
return false;
string[] MethodTokens = methodUrl.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
string[] BindingTokens = bindingUrl.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
int i, j;
for (i = 0, j = 0; i < BindingTokens.Length && j < MethodTokens.Length; i++, j++)
{
if (BindingTokens[i] == MethodTokens[j])
continue; // so far so good - keep going
if (BindingTokens[i] == "*")
{
if (MethodTokens[j] == "?")
return false; // cannot match /aaa/* to /aaa/?, because /aaa/? is wider.
else
continue; // it is a local wild card - anything goes
}
if (BindingTokens[i].StartsWith("{"))
continue; // this is a url parameter, which is for the purpose of matching as good as a local wild card
// note, that it is sufficient to check just the first character. The presence of the last one
// is ensured by the regular expression in binding parser
if (BindingTokens[i] == "?")
{
// it is a global wild card - we need to find a matching tail
if (++i >= BindingTokens.Length)
return true; // there is no tail to match - we can report a match
bool found = false;
for (; j < MethodTokens.Length; j++)
if (BindingTokens[i] == MethodTokens[j])
{
found = true;
break;
}
if (found)
continue;
}
return false; // no match
}
if (i < BindingTokens.Length) // items left in the binding
for (; i < BindingTokens.Length; i++) // if all of them are wild cards this is a match
if (BindingTokens[i] != "*" && BindingTokens[i] != "?" && !BindingTokens[i].StartsWith("{"))
return false;
// There is an implicit /? in the end of every binding
//if (j < MethodTokens.Length) // items left in the method url - no match
// return false;
return true;
}
/// <summary>
/// Matches the new binding to all methods
/// </summary>
/// <param name="binding"></param>
/// <returns>a list of all <see cref="BindingNode"/> matching the url </returns>
private IEnumerable<Binding> MatchMethodsToBinding(Binding binding)
{
List<Binding> result = new List<Binding>();
foreach (Binding child in bindings)
{
result.AddRange(child.MatchMethodsToBinding(binding));
if (child.isMethod && Match(child, binding))
result.Add(child);
}
return result;
}
/// <summary>
/// Matches the new node to all existing methods. If a match found clone
/// controllers from the matching method to the new method
/// </summary>
/// <param name="methodNode"></param>
/// <remarks>
/// this method is called for every method node when the node is created. <br/>
/// It recursively traverses the node tree looking if any existing method node
/// matches the new method node. It can only happen if the existing node
/// has a wild card url, otherwise our method node would already have been created
/// </remarks>
private void MatchBindingsToMethod(Binding methodNode)
{
foreach (Binding child in bindings)
{
child.MatchBindingsToMethod(methodNode);
// this is our node - we do not need to do it again
if (child == methodNode)
continue;
// this is not a method - skip it
if (!child.isMethod)
continue;
if (Match(methodNode, child))
// it is a match - all controllers from this method
// have to be cloned to our new method
foreach (Controller controller in child.controllers)
// methodNode.Register(new Controller(methodNode, controller));
methodNode.Register(methodNode, controller.Type, null);
}
}
private void RegisterBindings(Binding newBinding, Binding oldBinding)
{
foreach (KeyValuePair<string, Binding> binding in new List<KeyValuePair<string, Binding>>(partialUrls))
if (binding.Value == oldBinding)
partialUrls.Remove(binding.Key);
if (newBinding == null)
return;
string bindingUrl = newBinding.bindingUrl;
while (true)
{
partialUrls.Add(newBinding.verb + ',' + bindingUrl, newBinding);
if (bindingUrl.LastIndexOf('/') < 1)
break;
bindingUrl = bindingUrl.Substring(0, bindingUrl.LastIndexOf('/'));
}
}
public void Validate(Binding binding)
{
Validate("", binding);
}
public Engine()
{
root = new Binding(this);
}
internal Resource(Engine engine, Binding binding, string name)
{
this.name = name;
this.engine = engine;
this.binding = binding;
}
private void Adopt(Binding node, string newName)
{
}
private string buildKey(Binding binding) {return binding.Verb + ';' + binding.BindingUrl;}
private string GetTreeRecursive(string spacer, Binding leaf)
{
string result = String.Format("{1}{2} {0} \r\n",leaf.BindingUrl,spacer,leaf.Verb);
foreach (Controller ctrlr in leaf.Controllers)
{
result += String.Format("{1} Controller: {0} \r\n", ctrlr.Type.Name,spacer);
}
foreach (Binding bnd in leaf.Bindings)
{
result += GetTreeRecursive(spacer + " ",bnd);
}
return result;
}
public void Remove(Binding binding) { dictionary.Remove(buildKey(binding)); }
private string GetTreeResultText(string spacer, Binding leaf)
{
string result = String.Format("{1}Node(\"{2}{0}\",Controllers( \r\n", leaf.BindingUrl, spacer, spacer == " " ? leaf.Verb+" ":"");
bool first = false;
foreach (Controller ctrlr in (leaf.Controllers.OrderByDescending(ctrlr => ctrlr.SeqNumber)))
{
result += String.Format("{1} {2}\"{0}\" \r\n", ctrlr.Type.Name, spacer, (first ? "," : ""));
first = true;
}
result += String.Format("{0}){1}\r\n", spacer,(leaf.Bindings.Count>0? ",":"" ));
bool first1 = false;
foreach (Binding bnd in leaf.Bindings)
{
result += (first1 ? String.Format("{0},\r\n",spacer) : "") + GetTreeResultText(spacer + " ", bnd);
first1 = true;
}
result += String.Format("{0})\r\n", spacer);
return result;
}