public TaxonTreeViewItem(ITaxon taxon, TaxonTreeViewItem parent, int level, int id, bool isMainRelation)
{
Taxon = taxon;
Parent = parent;
Level = level;
Id = id;
IsMainRelation = isMainRelation;
if (!taxon.Category.IsTaxonomic)
{
CssClass = "non-taxonomic-label";
}
//Title = string.Format("{0} ({1})", HttpUtility.HtmlEncode(Name), HttpUtility.HtmlEncode(CommonName));
if (taxon.CommonName.IsNotEmpty())
{
Title = string.Format("{0} ({1})", HttpUtility.HtmlEncode(Name), HttpUtility.HtmlEncode(CommonName));
}
else
{
Title = string.Format("{0}", HttpUtility.HtmlEncode(Name));
}
//string pathName = VirtualPathUtility.ToAbsolute(@"~/Images/Icons/minus-small.png", "Scripts/Dynatree/src/skin");
//pathName = VirtualPathUtility.ToAppRelative(@"~/Images/Icons/minus-small.png", "Scripts/Dynatree/src/skin");
//pathName = "/Images/Icons/minus-small.png";
//if (parent.Taxon.rel)
//string pathName = "../../../../Images/Icons/minus-small.png";
//Icon = pathName;
}
/// <summary>
/// Loads the taxon tree
/// </summary>
/// <param name="rootTaxon">the root</param>
/// <param name="allDescendants">true if we should load all descendants. If false only the closest children is loaded</param>
/// <returns></returns>
public TaxonTreeViewItem LoadTaxonTree(ITaxon rootTaxon, bool allDescendants)
{
var root = new TaxonTreeViewItem(rootTaxon, null, 0, GetUniqueNumber(), true);
root.Children = LoadChildren(root, allDescendants);
root.IsExpanded = true;
return(root);
}
///// <summary>
///// Constructor
///// </summary>
///// <param name="taxonId"></param>
///// <param name="revisionId"></param>
///// <param name="revisionTaxonCategorySortOrder"></param>
//public TaxonTreeViewModel(int taxonId, int? revisionId, int? revisionTaxonCategorySortOrder) :
// this(CoreData.TaxonManager.GetTaxonById(CoreData.UserManager.GetCurrentUser(), taxonId, revisionId, revsionc))
//{
// this._revisionId = revisionId;
// this._revisionTaxonCategorySortOrder = revisionTaxonCategorySortOrder;
// IUserContext userContext = CoreData.UserManager.GetCurrentUser();
// ITaxon taxon = CoreData.TaxonManager.GetTaxonById(userContext, taxonId);
// _rootNode = LoadTaxonTree(taxon, false);
// TaxonTreeViewItem treeViewItem = GetTreeViewItemByTaxonId(taxonId);
// if (treeViewItem != null)
// {
// this.ActiveId = treeViewItem.Id;
// }
// // load parents
// BuildParentTaxaList(this.RootNode);
//}
public TaxonTreeViewModel(ITaxon taxon, int?revisionId, int?revisionTaxonCategorySortOrder)
{
this._revisionId = revisionId;
this._revisionTaxonCategorySortOrder = revisionTaxonCategorySortOrder;
_rootNode = LoadTaxonTree(taxon, false);
TaxonTreeViewItem treeViewItem = GetTreeViewItemByTaxonId(taxon.Id);
if (treeViewItem != null)
{
this.ActiveId = treeViewItem.Id;
}
// load parents
BuildParentTaxaList(this.RootNode);
}
/// <summary>
/// When the tree is recreated and the children isn't loaded then
/// this function loads the children.
/// </summary>
/// <param name="expandedTaxa"></param>
public void RecreateExpandedTaxaAfterRedraw(List <int> expandedTaxa)
{
if (expandedTaxa == null)
{
return;
}
foreach (int itemId in expandedTaxa)
{
TaxonTreeViewItem item = this.GetTreeViewItemById(itemId);
if (item == null || item.HasChildren)
{
continue;
}
item.Children = LoadChildren(item, false);
}
this.ExpandedTaxa = expandedTaxa;
}
/// <summary>
/// Returns an enumerator that iterates the tree items.
/// </summary>
/// <returns></returns>
public IEnumerable <TaxonTreeViewItem> GetTreeViewItemEnumerator()
{
var stack = new Stack <TaxonTreeViewItem>();
stack.Push(this.RootNode);
while (stack.Count > 0)
{
TaxonTreeViewItem current = stack.Pop();
yield return(current);
if (!current.HasChildren)
{
continue;
}
foreach (TaxonTreeViewItem item in current.Children)
{
stack.Push(item);
}
}
}
/// <summary>
/// Loads children
/// </summary>
/// <param name="parent">the parent</param>
/// <param name="allDescendants">true if we should load all descendants. If false only the closest children is loaded</param>
/// <returns></returns>
public List <TaxonTreeViewItem> LoadChildren(TaxonTreeViewItem parent, bool allDescendants)
{
IUserContext userContext = CoreData.UserManager.GetCurrentUser();
bool isInRevision = DyntaxaHelper.IsInRevision(userContext, this._revisionId);
var children = new List <TaxonTreeViewItem>();
var parentChilds = parent.Taxon.GetChildTaxonRelations(userContext, isInRevision, false);
foreach (ITaxonRelation taxonRelation in parentChilds)
{
if (!ShowSecondaryRelations.GetValueOrDefault(true))
{
if (!taxonRelation.IsMainRelation)
{
continue;
}
}
TaxonTreeViewItem item = new TaxonTreeViewItem(taxonRelation.ChildTaxon, parent, parent.Level + 1, GetUniqueNumber(), taxonRelation.IsMainRelation);
children.Add(item);
//TODO might be a problem if we are in a revision (should then use CheckedOutChangerChildTaxa)
if (isInRevision)
{
if (allDescendants && item.Taxon.GetNearestChildTaxonRelations(userContext).IsNotEmpty())
{
item.Children = LoadChildren(item, true);
}
}
else
{
if (allDescendants && item.Taxon.GetNearestChildTaxonRelations(userContext).IsNotEmpty())
{
item.Children = LoadChildren(item, true);
}
}
}
return(children);
}
/// <summary>
/// Builds a list with all parents.
/// The current taxon is also added last.
/// </summary>
/// <param name="rootTaxon"></param>
public void BuildParentTaxaList(TaxonTreeViewItem rootTaxon)
{
IUserContext userContext = CoreData.UserManager.GetCurrentUser();
bool isInRevision = DyntaxaHelper.IsInRevision(userContext, this._revisionId);
var allParents = (List <ITaxonRelation>)rootTaxon.Taxon.GetAllParentTaxonRelations(userContext, null, isInRevision, false);
var parents = allParents.GroupBy(x => x.ParentTaxon.Id).Select(x => x.First().ParentTaxon).ToList();
this.ParentTaxa = new List <TaxonTreeViewTaxon>();
string categoryName = null;
foreach (ITaxon parentTaxon in parents)
{
if (_revisionTaxonCategorySortOrder.HasValue)
{
if (parentTaxon.Category.SortOrder < _revisionTaxonCategorySortOrder.Value)
{
continue;
}
}
//var parentTaxon = taxonRelation.RelatedTaxon;
categoryName = parentTaxon.Category.Name;
this.ParentTaxa.Add(new TaxonTreeViewTaxon(parentTaxon.Id, parentTaxon.ScientificName.IsNotEmpty() ? parentTaxon.ScientificName : "-", categoryName));
}
categoryName = rootTaxon.Taxon.Category.Name;
this.ParentTaxa.Add(new TaxonTreeViewTaxon(rootTaxon.Taxon.Id, rootTaxon.Taxon.ScientificName.IsNotEmpty() ? rootTaxon.Taxon.ScientificName : "-", categoryName));
// decide which is current root
foreach (var item in this.ParentTaxa)
{
if (item.TaxonId == _rootNode.TaxonId)
{
item.IsCurrentRoot = true;
break;
}
}
}
