public bool IncludeChildrenOPCNodes(ICollection <FreeHierarchyTreeItem> children, bool isSelected = false, HashSet <long> selectedNodes = null,
bool includeChildren = true)
{
if (HierObject == null)
{
return(false);
}
Descriptor.NeedFindUaNode = true;
var mainNode = HierObject as TUANode;
var result = false;
if (mainNode == null || mainNode.DependentNodes == null)
{
return(false);
}
IsUaNodesInitializet = true;
var uadependentnodes = UAHierarchyDictionaries.UANodesDict.GetValues(
new HashSet <long>(mainNode.DependentNodes
.Where(c => c.UAReferenceType != EnumOpcReferenceType.HasTypeDefinition)
.Select(c => c.UANodeId)), Manager.UI.ShowMessage);
//Перебор всех зависимых OPC узлов
foreach (var dependentNode in uadependentnodes)
{
UserRightsForTreeObject right;
var isExistsRight = Manager.User.AccumulateRightsAndVerify(dependentNode, EnumObjectRightType.SeeDbObjects, HierObject.GetObjectRightType(), out right);
var selected = isSelected || (selectedNodes != null && selectedNodes.Contains(dependentNode.UANodeId));
var newItem = new FreeHierarchyTreeItem(Descriptor, dependentNode, selected, string.Empty, Descriptor.GetMinIdAndDecrement(), this, true,
nodeRights: right, freeHierItemType: EnumFreeHierarchyItemType.UANode);
var isExistsChildSeeDbObjects = false;
if (children.Any(i => i.GetKey == newItem.GetKey))
{
// newItem.Dispose();
return(result);
}
if (includeChildren)
{
isExistsChildSeeDbObjects = newItem.IncludeChildrenOPCNodes(newItem.Children, isSelected, selectedNodes);
}
//У объекта есть права на просмотр, или на дочерний объект
if (isExistsRight || isExistsChildSeeDbObjects)
{
children.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
result = true;
}
else
{
newItem.Dispose();
}
}
return(result);
}
/// <summary>
/// Генерация дерева (списка) балансов (приложения 63) для выгрузки xml
/// </summary>
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateBalance63Tree(FreeHierarchyTreeDescriptor descriptor)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
var rootNodes = DeclaratorService.Service.Get_ExportService_Balances63();
if (rootNodes == null)
{
return(result);
}
foreach (var rootNode in rootNodes)
{
var newItemNode = new FreeHierarchyTreeItem(descriptor, rootNode, false, string.Empty,
descriptor.GetMinIdAndDecrement(), null, true, nodeRights: null,
freeHierItemType: EnumFreeHierarchyItemType.FiasFullAddress);
//{
// StringName = rootNode.StringName,
//};
newItemNode.Descriptor.Tree = result;
//newItemNode.UpdateCountParents();
result[newItemNode.FreeHierItem_ID] = newItemNode;
}
return(result);
}
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateOldTelescopeTree(FreeHierarchyTreeDescriptor descriptor)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
var rootNodes = EnumClientServiceDictionary.OldTelescopeTreeNodes.Values.Where(i => i.TreeLevel == 0);
if (rootNodes == null)
{
return(result);
}
foreach (var rootNode in rootNodes)
{
rootNode.Parent_Absolute_Number = ""; //иначе зацикливание где нибудь будет
var newItemNode = new FreeHierarchyTreeItem(descriptor, rootNode, false, string.Empty,
descriptor.GetMinIdAndDecrement(), null, true, nodeRights: null,
freeHierItemType: EnumFreeHierarchyItemType.OldTelescopeTreeNode);
newItemNode.Descriptor.Tree = result;
result[newItemNode.FreeHierItem_ID] = newItemNode;
}
return(result);
}
public bool IncludeChildrenSection(int parentID, enumTypeHierarchy parentType, ICollection <FreeHierarchyTreeItem> children)
{
var isExistsSeeDbRights = false;
foreach (var section in GlobalSectionsDictionary.SectionsList.Values.Where(s => s.TypeParentHierarchy == parentType && s.ParentId == parentID))
{
UserRightsForTreeObject right;
if (!Manager.User.AccumulateRightsAndVerify(section, EnumObjectRightType.SeeDbObjects, HierObject.GetObjectRightType(), out right))
{
continue;
}
isExistsSeeDbRights = true;
var newItem = new FreeHierarchyTreeItem(Descriptor, section, false, string.Empty, Descriptor.GetMinIdAndDecrement(), this, true,
nodeRights: right, freeHierItemType: EnumFreeHierarchyItemType.Section);
children.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
newItem.Descriptor.Tree = Descriptor.Tree;
newItem.LoadStaticChildren(true);
}
return(isExistsSeeDbRights);
}
private bool IncludeForecastObjectChildren(ICollection <FreeHierarchyTreeItem> children)
{
bool result = false;
//Добавлем все константы формул
var forecastObject = HierObject as TForecastObject;
if (forecastObject == null || forecastObject.Children == null)
{
return(result);
}
//EnumClientServiceDictionary.ForecastObjectsDictionary.Prepare(new HashSet<string>(forecastObject.Children));
foreach (var forecastObjectUn in forecastObject.Children)
{
var forecastObjectChild = EnumClientServiceDictionary.ForecastObjectsDictionary[forecastObjectUn];
if (forecastObjectChild != null)
{
var newItem = new FreeHierarchyTreeItem(Descriptor, forecastObjectChild, false, string.Empty, Descriptor.GetMinIdAndDecrement(), this, true,
freeHierItemType: EnumFreeHierarchyItemType.ForecastObject);
children.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
newItem.Descriptor.Tree = Descriptor.Tree;
newItem.IncludeForecastObjectChildren(newItem.Children);
result = true;
}
}
return(result);
}
/// <summary>
/// Генерация стандартного дерева ПС
/// </summary>
/// <returns></returns>
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateStandartTreePS(FreeHierarchyTreeDescriptor descriptor, bool isHideTi)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
var hiers1 = EnumClientServiceDictionary.HierLev1List.Values;
var filterStatus = descriptor.FilterStatus;
foreach (var item in hiers1.OrderBy(v => v.Item)) //сортируем по названию
{
if (item == null ||
(filterStatus.HasValue && (item.TIStatus & filterStatus.Value) == EnumTIStatus.None) || //Используется фильтр на дереве
!IsGlobalFilterHaveItem(item)) //Глобальный фильтр
{
continue;
}
var isExistsChildSeeDbObjects = Manager.User.IsAssentRight(item, EnumObjectRightType.SeeDbObjects, null);
if (!isExistsChildSeeDbObjects && //Нет собственных прав
!FreeHierarchyTreePreparer.ExistsStandartChildSeeDbObjects(item, descriptor.Tree_ID ?? -101, true) //И нет дочерних объектов с правами
)
{
continue;
}
var newItem = new FreeHierarchyTreeItem(descriptor, item, false, item.Name, descriptor.GetMinIdAndDecrement(), null, true, isHideTi, item.ObjectRights,
EnumFreeHierarchyItemType.HierLev1)
{
Descriptor =
{
Tree = result
}
};
if (newItem.IncludeObjectChildren)
{
isExistsChildSeeDbObjects = newItem.LoadStaticChildren(isExistsChildSeeDbObjects, isHideTi);
}
//У объекта нет прав на просмотр, или нет дочерних объектов на которые есть такие права
//if (isExistsRight || isExistsChildSeeDbObjects)
//{
result[newItem.FreeHierItem_ID] = newItem;
//}
//else
//{
// newItem.Dispose();
//}
}
//if (FreeHierarchyTreeDescriptor.Sort != null) FreeHierarchyTreeDescriptor.Sort(items);
//foreach (var i in items) result[i.FreeHierItem_ID] = i;
return(result);
}
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateStandartTreeBySupplyPS(FreeHierarchyTreeDescriptor descriptor, bool isHideTi)
{
var items = new List <FreeHierarchyTreeItem>();
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
foreach (var value in from ps in EnumClientServiceDictionary.DetailPSList
join ps_sup in GlobalTreeDictionary.PowerSupply_PS_List on ps.Key equals ps_sup.PS_ID into temp
from ps_t in temp.DefaultIfEmpty()
where ps_t == null
orderby ps.Value.Name
select ps.Value)
{
if (!IsGlobalFilterHaveItem(value))
{
continue;
}
UserRightsForTreeObject right;
if (!Manager.User.AccumulateRightsAndVerify(value, EnumObjectRightType.SeeDbObjects, value.GetObjectRightType(), out right))
{
continue;
}
FreeHierarchyTreeItem newItem = new FreeHierarchyTreeItem(descriptor, value, nodeName: value.Name)
{
FreeHierItem_ID = descriptor.GetMinIdAndDecrement(),
IncludeObjectChildren = true,
IsHideTi = isHideTi,
FreeHierItemType = EnumFreeHierarchyItemType.PS,
NodeRights = right,
};
items.Add(newItem);
newItem.Descriptor.Tree = result;
if (newItem.IncludeObjectChildren)
{
newItem.LoadStaticChildren(true, isHideTi);
newItem.Descriptor.NeedFindTI = true;
}
}
if (FreeHierarchyTreeDescriptor.Sort != null)
{
FreeHierarchyTreeDescriptor.Sort(items);
}
foreach (var i in items)
{
result[i.FreeHierItem_ID] = i;
}
return(result);
}
private static FreeHierarchyTreeItem Create_FreeHierarchyTreeItem(int minID, KeyValuePair <Guid, TFIASNode> obj, FreeHierarchyTreeDescriptor descriptor)
{
var newItemNode = new FreeHierarchyTreeItem(descriptor, obj.Value)
{
FreeHierItem_ID = minID,
IncludeObjectChildren = true,
FreeHierItemType = EnumFreeHierarchyItemType.FiasFullAddress,
NodeRights = null,
StringName = obj.Value.StringName,
FIASNode = obj.Value,
};
return(newItemNode);
}
public static ID_TypeHierarchy AsTypeHierarchy(this FreeHierarchyTreeItem item)
{
if (item == null)
{
return(null);
}
return(new ID_TypeHierarchy
{
ID = item.HierObject.Id,
StringId = item.HierObject.StringId,
TypeHierarchy = item.HierObject.Type,
FreeHierItemId = item.FreeHierItem_ID < 0 ? null : (int?)item.FreeHierItem_ID
});
}
/// <summary>
/// Генерация стандартного дерева FIAS адреса, которые используются
/// </summary>
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateStandartTree_FIAS(bool IncludeHerarchyObjects, FreeHierarchyTreeDescriptor descriptor)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
//добавляем корневые узлы
IEnumerable <TFIASNode> rootNodes;
if (!IncludeHerarchyObjects)
{
rootNodes = DeclaratorService.FIAS_Get_RootNodes();
}
else
{
rootNodes = DeclaratorService.FIASToHierarchy_Get_RootNodes();
}
if (rootNodes == null)
{
return(result);
}
foreach (var rootNode in rootNodes)
{
var newItemNode = new FreeHierarchyTreeItem(descriptor, rootNode, false, string.Empty, descriptor.GetMinIdAndDecrement(), null, true, nodeRights: null,
freeHierItemType: EnumFreeHierarchyItemType.FiasFullAddress)
{
StringName = rootNode.StringName,
FIASNode = rootNode,
};
newItemNode.Descriptor.Tree = result;
//newItemNode.UpdateCountParents();
//добавляем дочерние
if (rootNode.IsChildrenExists)
{
newItemNode.IncludeChildrenFIASNodes((rootNode.IsHierObjectExists || descriptor.Tree_ID == TreeTypeStandart_Dict_FIASToHierarchy));
}
result[newItemNode.FreeHierItem_ID] = newItemNode;
}
return(result);
}
// добавление ТП
private static void addTP(FreeHierarchyTreeItem parent, TPoint tp, ref int minID,
FreeHierarchyTreeDescriptor descriptor, ConcurrentDictionary <int, FreeHierarchyTreeItem> result, List <int> removedTp)
{
minID--;
var newTP = new FreeHierarchyTreeItem(descriptor, tp)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.TP,
Parent = parent,
NodeRights = parent.HierObject.GetObjectRightType(),
IsChildrenInitializet = true,
};
parent.Children.Add(newTP);
result.TryAdd(minID, newTP);
removedTp.Add(minID);
newTP.Descriptor.Tree = result;
}
private void IncludeChildrenBalances(ICollection <FreeHierarchyTreeItem> chidren)
{
//var objectIds = new HashSet<ID_TypeHierarchy>(chidren.Where(o=>o.HierObject!=null).Select(o => new ID_TypeHierarchy
//{
// TypeHierarchy = o.HierObject.Type,
// ID = o.HierObject.Id,
// StringId = o.HierObject.StringId,
//}), new ID_TypeHierarchy_EqualityComparer());
//EnumClientServiceDictionary.FreeHierarchyBalances.Prepare(objectIds, Manager.UI.ShowMessage);
if (HierObject == null)
{
return;
}
List <ServiceReference.ARM_20_Service.Info_Balance_FreeHierarchy_List> objectBalances;
if (!EnumClientServiceDictionary.FreeHierarchyBalancesByParent.TryGetValue(new ID_TypeHierarchy
{
TypeHierarchy = HierObject.Type,
ID = HierObject.Id,
StringId = HierObject.StringId,
}, out objectBalances, false) || objectBalances == null || objectBalances.Count == 0)
{
return;
}
foreach (var balance in objectBalances)
{
if (balance.BalanceFreeHierarchyType_ID > 1)
{
continue; //Допустимы только балансы ЭЭ
}
var newItem = new FreeHierarchyTreeItem(Descriptor, balance, false, string.Empty,
Descriptor.GetMinIdAndDecrement(), this, true,
freeHierItemType: EnumFreeHierarchyItemType.UniversalBalance, isChildrenInitializet: true);
chidren.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
newItem.Descriptor.Tree = Descriptor.Tree;
}
}
public void RemoveAddSelected(bool isAdd, FreeHierarchyTreeItem item)
{
if (_treeItemsSyncLock.TryEnterWriteLock(TimeSpan.FromSeconds(5)))
{
try
{
if (isAdd)
{
SelectedItems[item.FreeHierItem_ID] = item;
}
else
{
SelectedItems.Remove(item.FreeHierItem_ID);
}
}
finally
{
_treeItemsSyncLock.ExitWriteLock();
}
}
}
private void IncludeChildrenFormulaConstant(ICollection <FreeHierarchyTreeItem> chidren)
{
//Добавлем все константы формул
var withChildrenObject = HierObject as IFreeHierarchyObjectWithChildren;
if (withChildrenObject == null || withChildrenObject.FormulaConstants == null)
{
return;
}
var isSelected = IsSelectedChildren;
foreach (var constant in withChildrenObject.FormulaConstants)
{
var newItem = new FreeHierarchyTreeItem(Descriptor, constant, isSelected, string.Empty,
Descriptor.GetMinIdAndDecrement(), this, true,
freeHierItemType: EnumFreeHierarchyItemType.FormulaConstant, isChildrenInitializet: true);
chidren.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
newItem.Descriptor.Tree = Descriptor.Tree;
}
}
public bool IncludeChildrenFormulas(long parentID, enumTypeHierarchy parentType, ICollection <FreeHierarchyTreeItem> children)
{
if (EnumClientServiceDictionary.FormulasList == null)
{
return(false);
}
bool result = false;
var isSelected = IsSelectedChildren;
foreach (var f in EnumClientServiceDictionary.FormulasList.Where(i => i.Value.ParentId == parentID && i.Value.ParentType == parentType))
{
var newItem = new FreeHierarchyTreeItem(Descriptor, f.Value, isSelected, string.Empty, Descriptor.GetMinIdAndDecrement(), this, true,
freeHierItemType: EnumFreeHierarchyItemType.Formula, isChildrenInitializet: true);
children.Add(newItem);
Descriptor.Tree.TryAdd(newItem.FreeHierItem_ID, newItem);
newItem.Descriptor.Tree = Descriptor.Tree;
result = true;
}
return(result);
}
public void Dispose()
{
try
{
FreeHierarchyTree = null;
SelectedChanged = null;
SelectedItems = null;
//ContextMenu = null;
//if (Tree != null && Tree.Count > 0)
//{
// foreach (var t in Tree.Values.ToList())
// {
// if (t == null) continue;
// t.Dispose();
// }
// Tree = null;
//}
if (PreviousSelected != null)
{
PreviousSelected.Dispose();
PreviousSelected = null;
}
if (Tree != null)
{
Tree = null;
}
}
catch
{
}
}
private static bool buildParents(FreeHierarchyTreeItem item, bool isFactPowerTree, bool isExistsContractRight, bool isExistsChildSeeDbObjects, ref int minID, out UserRightsForTreeObject parentRights)
{
parentRights = null;
isExistsContractRight = isExistsContractRight | Manager.User.IsAssentRight(item.NodeRights, EnumObjectRightType.SeeDbObjects);
int parentID = -1;
enumTypeHierarchy parentType = enumTypeHierarchy.Unknown;
var juridicalPerson = item.HierObject as TJuridicalPerson;
if (juridicalPerson != null && juridicalPerson.ParrentID != null)
{
//Не строим юр. лица у которых отсутствует родитель
parentID = juridicalPerson.ParrentID.ID;
parentType = juridicalPerson.ParrentID.TypeHierarchy;
}
else
{
var section = item.HierObject as TSection;
if (section != null)
{
parentID = section.ParentId;
parentType = section.TypeParentHierarchy;
}
}
bool isNew = true, isNewNext = false;
var saveItem = item;
var isParrentExists = true;
//Права уровня ПС
UserRightsForTreeObject hietLevPsRights = null;
//Права уровня 3
UserRightsForTreeObject hietLev3Rights = null;
//Права уровня 2
UserRightsForTreeObject hietLev2Rights = null;
var removedFreeItems = new Stack <Tuple <FreeHierarchyTreeItem, bool> >();
while (isParrentExists && parentType != enumTypeHierarchy.Dict_HierLev0)
{
switch (parentType)
{
case enumTypeHierarchy.Dict_PS:
TPSHierarchy ps;
if (!EnumClientServiceDictionary.DetailPSList.TryGetValue(parentID, out ps) || ps == null)
{
isParrentExists = false;
break;
}
if (isFactPowerTree)
{
Manager.User.AccumulateRightsAndVerify(ps, EnumObjectRightType.SeeDbObjects, null, out hietLevPsRights);
FreeHierarchyTreeItem psFreeHierarchyTreeItem =
item.Descriptor.Tree.Select(i => i.Value)
.FirstOrDefault(i => i.FreeHierItemType == EnumFreeHierarchyItemType.PS && i.HierObject != null && i.HierObject.Id == parentID);
if (psFreeHierarchyTreeItem == null)
{
minID--;
psFreeHierarchyTreeItem = new FreeHierarchyTreeItem(item.Descriptor, ps)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.PS,
IsChildrenInitializet = true,
};
item.Descriptor.Tree.TryAdd(minID, psFreeHierarchyTreeItem);
isNewNext = true;
}
else
{
isNewNext = false;
}
if (isNew)
{
psFreeHierarchyTreeItem.Children.Add(item);
}
removedFreeItems.Push(new Tuple <FreeHierarchyTreeItem, bool>(psFreeHierarchyTreeItem, isNew));
isNew = isNewNext;
item.Parent = psFreeHierarchyTreeItem;
item = psFreeHierarchyTreeItem;
}
parentID = ps.ParentId;
parentType = enumTypeHierarchy.Dict_HierLev3;
break;
case enumTypeHierarchy.Dict_HierLev3:
THierarchyDbTreeObject hier3Hierarchy;
if (!EnumClientServiceDictionary.HierLev3List.TryGetValue(parentID, out hier3Hierarchy) || hier3Hierarchy == null)
{
isParrentExists = false;
break;
}
if (isFactPowerTree)
{
Manager.User.AccumulateRightsAndVerify(hier3Hierarchy, EnumObjectRightType.SeeDbObjects, null, out hietLev3Rights);
FreeHierarchyTreeItem hierLev3FreeHierarchyTreeItem =
item.Descriptor.Tree.Values
.FirstOrDefault(i => i.FreeHierItemType == EnumFreeHierarchyItemType.HierLev3 && i.HierObject != null && i.HierObject.Id == parentID);
if (hierLev3FreeHierarchyTreeItem == null)
{
minID--;
hierLev3FreeHierarchyTreeItem = new FreeHierarchyTreeItem(item.Descriptor, hier3Hierarchy)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.HierLev3,
IsChildrenInitializet = true,
};
item.Descriptor.Tree.TryAdd(minID, hierLev3FreeHierarchyTreeItem);
isNewNext = true;
}
else
{
isNewNext = false;
}
if (isNew)
{
hierLev3FreeHierarchyTreeItem.Children.Add(item);
}
removedFreeItems.Push(new Tuple <FreeHierarchyTreeItem, bool>(hierLev3FreeHierarchyTreeItem, isNew));
isNew = isNewNext;
item.Parent = hierLev3FreeHierarchyTreeItem;
item = hierLev3FreeHierarchyTreeItem;
}
parentID = hier3Hierarchy.ParentId;
parentType = enumTypeHierarchy.Dict_HierLev2;
break;
case enumTypeHierarchy.Dict_HierLev2:
THierarchyDbTreeObject hier2Hierarchy;
if (!EnumClientServiceDictionary.HierLev2List.TryGetValue(parentID, out hier2Hierarchy) || hier2Hierarchy == null)
{
isParrentExists = false;
break;
}
Manager.User.AccumulateRightsAndVerify(hier2Hierarchy, EnumObjectRightType.SeeDbObjects, null, out hietLev2Rights);
FreeHierarchyTreeItem hierLev2 = item.Descriptor.Tree.Select(i => i.Value)
.FirstOrDefault(i => i.FreeHierItemType == EnumFreeHierarchyItemType.HierLev2 && i.HierObject != null && i.HierObject.Id == parentID);
if (hierLev2 == null)
{
minID--;
hierLev2 = new FreeHierarchyTreeItem(item.Descriptor, EnumClientServiceDictionary.HierLev2List[parentID])
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.HierLev2,
IsChildrenInitializet = true,
};
item.Descriptor.Tree.TryAdd(minID, hierLev2);
isNewNext = true;
}
else
{
isNewNext = false;
}
if (isNew)
{
hierLev2.Children.Add(item);
}
removedFreeItems.Push(new Tuple <FreeHierarchyTreeItem, bool>(hierLev2, isNew));
isNew = isNewNext;
item.Parent = hierLev2;
item = hierLev2;
parentID = item.HierObject.ParentId;
parentType = enumTypeHierarchy.Dict_HierLev1;
break;
case enumTypeHierarchy.Dict_HierLev1:
THierarchyDbTreeObject hier1Hierarchy;
if (!EnumClientServiceDictionary.HierLev1List.TryGetValue(parentID, out hier1Hierarchy) || hier1Hierarchy == null)
{
isParrentExists = false;
break;
}
UserRightsForTreeObject hietLev1Rights = null;
isExistsContractRight = Manager.User.AccumulateRightsAndVerify(hier1Hierarchy, EnumObjectRightType.SeeDbObjects, null, out hietLev1Rights) | isExistsChildSeeDbObjects;
UserRightsForTreeObject rights = hietLev1Rights;
//while (removedFreeItems.Count > 0)
var ri = new Stack <Tuple <FreeHierarchyTreeItem, bool> >();
while (removedFreeItems.Count > 0)
{
var removedFreeItem = removedFreeItems.Pop();
ri.Push(removedFreeItem);
isExistsContractRight = Manager.User.AccumulateRightsAndVerify(removedFreeItem.Item1.HierObject, EnumObjectRightType.SeeDbObjects, rights, out rights) |
isExistsContractRight;
removedFreeItem.Item1.NodeRights = rights;
}
//Проверкак прав, убираем если нет прав
if (!isExistsContractRight && !isExistsChildSeeDbObjects)
{
isParrentExists = false;
var removedChild = saveItem;
while (ri.Count > 0)
{
//removedChild.Parent = null;
var removedFreeItem = ri.Pop();
if (removedFreeItem.Item2)
{
FreeHierarchyTreeItem removed;
removedChild.Descriptor.Tree.TryRemove(removedFreeItem.Item1.FreeHierItem_ID, out removed);
}
removedFreeItem.Item1.Children.Remove(removedChild);
removedChild = removedFreeItem.Item1;
}
break;
}
parentRights = rights;
FreeHierarchyTreeItem hierLev1 =
item.Descriptor.Tree.Select(i => i.Value)
.FirstOrDefault(i => i.FreeHierItemType == EnumFreeHierarchyItemType.HierLev1 && i.HierObject != null && i.HierObject.Id == parentID);
if (hierLev1 == null)
{
minID--;
hierLev1 = new FreeHierarchyTreeItem(item.Descriptor, EnumClientServiceDictionary.HierLev1List[parentID])
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.HierLev1,
IsChildrenInitializet = true,
};
item.Descriptor.Tree.TryAdd(minID, hierLev1);
isNewNext = true;
}
else
{
isNewNext = false;
}
if (isNew)
{
hierLev1.Children.Add(item);
}
isNew = isNewNext;
item.Parent = hierLev1;
item = hierLev1;
parentID = item.HierObject.ParentId;
parentType = enumTypeHierarchy.Dict_HierLev0;
break;
case enumTypeHierarchy.Unknown:
isParrentExists = false;
break;
}
}
return(isParrentExists);
}
public static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateJuridicalPersonTree(FreeHierarchyTreeDescriptor descriptor, bool isFactPowerTree, bool isAddVoidJuridicalPerson)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
int minID = -1;
var directConsumerDictionary = new Dictionary <int, Dictionary <int, FreeHierarchyTreeItem> >();
var juridicalPersonsDictionary = new Dictionary <int, FreeHierarchyTreeItem>();
var sectionsWithContracts = new HashSet <int>();
// Построение договоров
foreach (var contract in EnumClientServiceDictionary.ContractDict.Values)
{
List <int> sectionIds;
if (EnumClientServiceDictionary.SectionByContract == null || !EnumClientServiceDictionary.SectionByContract.TryGetValue(contract.JuridicalPersonContract_ID, out sectionIds) || sectionIds == null)
{
continue;
}
if (isFactPowerTree)
{
sectionsWithContracts.UnionWith(sectionIds);
}
UserRightsForTreeObject juridicalPersonRight = null;
FreeHierarchyTreeItem juridicalPersonHierarchyItem = null;
TJuridicalPerson juridicalPerson;
var isExistsJuridicalPersonRight = false;
int? rId = null;
bool isNewPerson = false;
// построение Юридических лиц
if (EnumClientServiceDictionary.JuridicalPersonByContract.TryGetValue(contract.JuridicalPersonContract_ID, out juridicalPerson))
{
isExistsJuridicalPersonRight = Manager.User.AccumulateRightsAndVerify(juridicalPerson, EnumObjectRightType.SeeDbObjects, null, out juridicalPersonRight);
isNewPerson = !juridicalPersonsDictionary.TryGetValue(juridicalPerson.Item.JuridicalPerson_ID, out juridicalPersonHierarchyItem);
if (isNewPerson || juridicalPersonHierarchyItem == null)
{
minID--;
juridicalPersonHierarchyItem = new FreeHierarchyTreeItem(descriptor, juridicalPerson)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.JuridicalPerson,
NodeRights = juridicalPersonRight,
IsChildrenInitializet = true,
};
// построение родителей иерархической структуры
rId = minID;
juridicalPersonsDictionary[juridicalPerson.Item.JuridicalPerson_ID] = juridicalPersonHierarchyItem;
}
}
UserRightsForTreeObject contractRight;
var isExistsContractRight = Manager.User.AccumulateRightsAndVerify(contract, EnumObjectRightType.SeeDbObjects, juridicalPersonRight, out contractRight);
minID--;
var contractTreeId = minID;
var newContract = new FreeHierarchyTreeItem(descriptor, contract)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.Contract,
NodeRights = contractRight,
Parent = juridicalPersonHierarchyItem,
IsChildrenInitializet = true,
};
var isExistsChildSeeDbObjects = false;
var absentSections = new Dictionary <int, FreeHierarchyTreeItem>();
var removedItems = new List <int>();
// построение сечений
foreach (var section in sectionIds.Select(s => GlobalSectionsDictionary.SectionsList[s]))
{
if (section == null)
{
continue;
}
UserRightsForTreeObject sectionRight;
var isExistsSectionRight = Manager.User.AccumulateRightsAndVerify(section, EnumObjectRightType.SeeDbObjects, contractRight, out sectionRight);
if (sectionRight.IsDeniedRight(EnumObjectRightType.SeeDbObjects))
{
continue;
}
minID--;
var newSection = new FreeHierarchyTreeItem(descriptor, section)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.Section,
Parent = newContract,
NodeRights = sectionRight,
IsChildrenInitializet = true,
};
var sectionTreeId = minID;
var isExistsSectionChildrenRight = false;
var removedTp = new List <int>();
Dictionary <int, FreeHierarchyTreeItem> dirConsumers;
directConsumerDictionary.TryGetValue(section.Section_ID, out dirConsumers);
if (section.TP != null)
{
foreach (var tp in section.TP.OrderBy(s => s.Item.StringName))
{
if (tp.DirectConsumer_ID != null)
{
if (dirConsumers == null)
{
dirConsumers = new Dictionary <int, FreeHierarchyTreeItem>();
directConsumerDictionary.Add(section.Section_ID, dirConsumers);
}
FreeHierarchyTreeItem dirCon = null;
if (!dirConsumers.TryGetValue(tp.DirectConsumer_ID.Value, out dirCon) || dirCon == null)
{
var dc = EnumClientServiceDictionary.DirectConsumers[tp.DirectConsumer_ID.Value];
UserRightsForTreeObject directConsumerRight;
if (!Manager.User.AccumulateRightsAndVerify(dc, EnumObjectRightType.SeeDbObjects, sectionRight, out directConsumerRight))
{
continue;
}
isExistsSectionChildrenRight = true;
minID--;
dirCon = new FreeHierarchyTreeItem(descriptor, dc)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.DirectConsumer,
Parent = newSection,
NodeRights = directConsumerRight,
IsChildrenInitializet = true,
};
newSection.Children.Add(dirCon);
result.TryAdd(minID, dirCon);
removedTp.Add(minID);
dirCon.Descriptor.Tree = result;
dirConsumers[dc.DirectConsumer_ID] = dirCon;
}
// добавление ТП в объект ЭПУ
addTP(dirCon, tp, ref minID, descriptor, result, removedTp);
}
// добавление ТП в сечение (в случае, если ТП не связано с прямым потребителем)
else
{
addTP(newSection, tp, ref minID, descriptor, result, removedTp);
}
}
}
if (isExistsSectionRight || isExistsSectionChildrenRight)
{
isExistsChildSeeDbObjects = true;
newContract.Children.Add(newSection);
result.TryAdd(sectionTreeId, newSection);
newSection.Descriptor.Tree = result;
}
else
{
removedItems.AddRange(removedTp);
absentSections.Add(sectionTreeId, newSection);
}
}
if (juridicalPersonHierarchyItem != null)
{
if (isNewPerson)
{
UserRightsForTreeObject parentRights;
buildParents(juridicalPersonHierarchyItem, isFactPowerTree, isExistsJuridicalPersonRight | isExistsContractRight, isExistsChildSeeDbObjects,
ref minID,
out parentRights);
juridicalPersonHierarchyItem.NodeRights = parentRights.AccamulateRights(juridicalPersonRight);
}
isExistsContractRight = isExistsContractRight |
Manager.User.IsAssentRight(juridicalPersonHierarchyItem.HierObject.GetObjectRightType(), EnumObjectRightType.SeeDbObjects);
if (isExistsContractRight || isExistsChildSeeDbObjects)
{
newContract.NodeRights = newContract.NodeRights.AccamulateRights(juridicalPersonHierarchyItem.NodeRights);
//Добавляем пропущенные сечения
foreach (var freeHierarchyTreeItem in absentSections)
{
freeHierarchyTreeItem.Value.NodeRights = freeHierarchyTreeItem.Value.NodeRights.AccamulateRights(juridicalPersonHierarchyItem.NodeRights);
newContract.Children.Add(freeHierarchyTreeItem.Value);
result.TryAdd(freeHierarchyTreeItem.Key, freeHierarchyTreeItem.Value);
freeHierarchyTreeItem.Value.Descriptor.Tree = result;
removedItems.Add(freeHierarchyTreeItem.Key);
foreach (var sectionChildren in freeHierarchyTreeItem.Value.Children)
{
sectionChildren.NodeRights = sectionChildren.NodeRights.AccamulateRights(juridicalPersonHierarchyItem.NodeRights);
}
}
if (isNewPerson && rId.HasValue)
{
juridicalPersonHierarchyItem.Descriptor.Tree = result;
result.TryAdd(rId.Value, juridicalPersonHierarchyItem);
removedItems.Add(rId.Value);
}
juridicalPersonHierarchyItem.Children.Add(newContract);
}
}
if (isExistsContractRight || isExistsChildSeeDbObjects)
{
newContract.Descriptor.Tree = result;
result.TryAdd(contractTreeId, newContract);
}
else
{
//Удаление т.к. нет прав
foreach (var removedItemId in removedItems)
{
FreeHierarchyTreeItem removed;
result.TryRemove(removedItemId, out removed);
}
}
}
//Добавляем пропущенные юр. лица (у которых нет привязки к контракту)
if (isAddVoidJuridicalPerson)
{
var contractByPersonDict = EnumClientServiceDictionary.ContractByPersonDict;
//contractByPersonDict.Prepare(new HashSet<int>(EnumClientServiceDictionary.JuridicalPersonsDict.Values.Select(jp=>jp.Item.JuridicalPerson_ID)));
foreach (var juridicalPerson in EnumClientServiceDictionary.JuridicalPersonsDict.Values)
{
var id = juridicalPerson.Item.JuridicalPerson_ID;
//пропускаем уже добавленные или те на которые нехватает прав
if (juridicalPersonsDictionary.ContainsKey(id))
{
continue;
}
UserRightsForTreeObject juridicalPersonRight;
var isExistsJuridicalPersonRight = Manager.User.AccumulateRightsAndVerify(juridicalPerson, EnumObjectRightType.SeeDbObjects, null, out juridicalPersonRight);
var rId = --minID;
var juridicalPersonHierarchyItem = new FreeHierarchyTreeItem(descriptor, juridicalPerson)
{
FreeHierItem_ID = rId,
FreeHierItemType = EnumFreeHierarchyItemType.JuridicalPerson,
NodeRights = juridicalPerson.GetObjectRightType(),
};
var isExistsContractRight = false;
UserRightsForTreeObject parentRights;
buildParents(juridicalPersonHierarchyItem, isFactPowerTree, isExistsJuridicalPersonRight, isExistsContractRight,
ref minID,
out parentRights);
juridicalPersonHierarchyItem.NodeRights = parentRights.AccamulateRights(juridicalPersonRight);
List <Dict_JuridicalPersons_Contract> contracts;
if (contractByPersonDict != null && contractByPersonDict.TryGetValue(id, out contracts) && contracts.Count > 0)
{
//Перебирам контракты для этого юр. лица
foreach (var contract in contracts)
{
UserRightsForTreeObject contractRight;
if (!Manager.User.AccumulateRightsAndVerify(contract, EnumObjectRightType.SeeDbObjects, juridicalPersonHierarchyItem.NodeRights, out contractRight))
{
continue;
}
isExistsContractRight = true;
FreeHierarchyTreeItem newContract = new FreeHierarchyTreeItem(descriptor, contract)
{
FreeHierItem_ID = --minID,
FreeHierItemType = EnumFreeHierarchyItemType.Contract,
NodeRights = contractRight,
Parent = juridicalPersonHierarchyItem,
};
newContract.NodeRights = newContract.NodeRights.AccamulateRights(juridicalPersonHierarchyItem.NodeRights);
newContract.Descriptor.Tree = result;
juridicalPersonHierarchyItem.Children.Add(newContract);
result.TryAdd(minID, newContract);
}
}
if (Manager.User.IsAssentRight(juridicalPersonHierarchyItem.NodeRights, EnumObjectRightType.SeeDbObjects) || isExistsContractRight)
{
juridicalPersonHierarchyItem.Descriptor.Tree = result;
result.TryAdd(rId, juridicalPersonHierarchyItem);
}
}
}
if (isFactPowerTree)
{
// добавление оставшихся сечений (те, что не привязаны к юр.лицам и договорам)
foreach (var section in GlobalSectionsDictionary.SectionsList.Values)
{
if (section.Section_ID <= 0 || sectionsWithContracts.Contains(section.Section_ID))
{
continue;
}
minID--;
UserRightsForTreeObject sectionRight;
var isExistsSectionRight = Manager.User.AccumulateRightsAndVerify(section, EnumObjectRightType.SeeDbObjects, null, out sectionRight);
var newSection = new FreeHierarchyTreeItem(descriptor, section)
{
FreeHierItem_ID = minID,
FreeHierItemType = EnumFreeHierarchyItemType.Section,
};
var rId = minID;
newSection.Descriptor.Tree = result;
// построение родителей иерархической структуры
UserRightsForTreeObject parentRights = null;
buildParents(newSection, true, isExistsSectionRight, isExistsSectionRight, ref minID, out parentRights);
newSection.NodeRights = parentRights;
if (section.TP != null)
{
result[rId] = newSection;
var removedTp = new List <int>();
foreach (var tp in section.TP)
{
addTP(newSection, tp, ref minID, descriptor, result, removedTp);
}
}
}
}
// просчет кол-ва элементов всех узлов и сортировка
countElements(result.Where(i => i.Value.Parent == null).Select(i => i.Value));
return(result);
}
/// <summary>
/// Генерация стандартного дерева Список OPCUA серверов
/// </summary>
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateStandartTree_Dict_OPCUAServers(FreeHierarchyTreeDescriptor descriptor)
{
var items = new List <FreeHierarchyTreeItem>();
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
var uaServers = UAHierarchyDictionaries.UaServers(Manager.UI.ShowMessage);
if (uaServers == null)
{
return(null);
}
descriptor.NeedFindUaNode = true;
foreach (var item in uaServers.Values)
{
UserRightsForTreeObject right;
if (!Manager.User.AccumulateRightsAndVerify(item, EnumObjectRightType.SeeDbObjects, null, out right))
{
continue;
}
var newItem = new FreeHierarchyTreeItem(descriptor, item)
{
FreeHierItem_ID = descriptor.GetMinIdAndDecrement(),
IncludeObjectChildren = true,
IsHideTi = false,
FreeHierItemType = EnumFreeHierarchyItemType.UAServer,
NodeRights = null,
};
newItem.Descriptor.Tree = result;
items.Add(newItem);
//дабавляем корневые узлы вручную
//дальше будут подгружаться при раскрытии?
List <TUANode> rootNodes = UAService.Service.UA_Get_RootNodes(item.UAServer_ID);
foreach (var rootNode in rootNodes)
{
TUANode node = null;
UAHierarchyDictionaries.UANodesDict.TryGetValue(rootNode.UANodeId, out node);
if (node == null)
{
continue;
}
FreeHierarchyTreeItem newItemNode = new FreeHierarchyTreeItem(newItem.Descriptor, node)
{
FreeHierItem_ID = descriptor.GetMinIdAndDecrement(),
Parent = newItem,
IncludeObjectChildren = true,
FreeHierItemType = EnumFreeHierarchyItemType.UANode,
NodeRights = right,
};
newItem.Children.Add(newItemNode);
newItem.Descriptor.Tree.TryAdd(newItemNode.FreeHierItem_ID, newItemNode);
//добавляем дочерние
//newItemNode.IncludeChildrenOPCNodes(newItemNode.Children, false);
}
}
if (FreeHierarchyTreeDescriptor.Sort != null)
{
FreeHierarchyTreeDescriptor.Sort(items);
}
foreach (var i in items)
{
result[i.FreeHierItem_ID] = i;
}
return(result);
}
private static ConcurrentDictionary <int, FreeHierarchyTreeItem> GenerateStandartTreeSections(FreeHierarchyTreeDescriptor descriptor)
{
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
var items = new List <FreeHierarchyTreeItem>();
HashSet <ID_TypeHierarchy> objectsHasRightDbSee = null;
var hiers1 = EnumClientServiceDictionary.HierLev1List.Values;
if (Manager.User != null && !Manager.User.IsAdmin)
{
try
{
//Запрашиваем права на список объектов
objectsHasRightDbSee = Manager.User.UserHasRightDbSee(hiers1.Select(h1 => new ID_TypeHierarchy
{
ID = h1.Id,
TypeHierarchy = enumTypeHierarchy.Dict_HierLev1,
}).ToList());
}
catch (Exception ex)
{
Manager.UI.ShowMessage("Ошибка запроса прав: " + ex.Message);
}
}
foreach (var item in hiers1.OrderBy(v => v.Item))
{
//Глобальный фильтр
if (!IsGlobalFilterHaveItem(item))
{
continue;
}
var minID = descriptor.GetMinIdAndDecrement();
UserRightsForTreeObject hier1Right;
var isExistsRight = Manager.User.AccumulateRightsAndVerify(item, EnumObjectRightType.SeeDbObjects, null, out hier1Right);
if (!isExistsRight && Manager.User != null && !Manager.User.IsAdmin && objectsHasRightDbSee != null)
{
//Проверяем через дочерних объектов
isExistsRight = objectsHasRightDbSee.Any(o => o.ID == item.Id && o.TypeHierarchy == item.GetTypeHierarchy());
}
var newItem = new FreeHierarchyTreeItem(descriptor, item, nodeName: item.Name)
{
FreeHierItem_ID = minID,
IncludeObjectChildren = true,
FreeHierItemType = EnumFreeHierarchyItemType.HierLev1,
NodeRights = hier1Right
};
newItem.Descriptor.Tree = result;
bool isExistsChildSeeDbObjects = false;
if (newItem.IncludeObjectChildren)
{
isExistsChildSeeDbObjects = newItem.LoadStaticChildren(isExistsRight, isLoadStatic: true);
}
isExistsChildSeeDbObjects = newItem.IncludeChildrenSection(item.Id, item.Type, newItem.Children) || isExistsChildSeeDbObjects ||
item.TIStatus.HasFlag(EnumTIStatus.Is_Section_Enabled);
//У объекта нет прав на просмотр, или нет дочерних объектов на которые есть такие права
if (isExistsChildSeeDbObjects) //Включаем только если есть сечения
{
items.Add(newItem);
}
else
{
newItem.Dispose();
}
}
//Сечения которые не привязаны ни к чему
foreach (var section in EnumClientServiceDictionary.GetSections().Values.Where(s => s.ParentId <= 0 && s.Section_ID > 0).OrderBy(s => s.Item))
{
UserRightsForTreeObject right;
if (!Manager.User.AccumulateRightsAndVerify(section, EnumObjectRightType.SeeDbObjects, null, out right))
{
continue;
}
var minID = descriptor.GetMinIdAndDecrement();
FreeHierarchyTreeItem newItem = new FreeHierarchyTreeItem(descriptor, section)
{
FreeHierItem_ID = minID,
IncludeObjectChildren = true,
NodeRights = right,
FreeHierItemType = EnumFreeHierarchyItemType.Section,
};
newItem.Descriptor.Tree = result;
newItem.LoadStaticChildren(true);
items.Add(newItem);
}
if (FreeHierarchyTreeDescriptor.Sort != null)
{
FreeHierarchyTreeDescriptor.Sort(items);
}
foreach (var i in items)
{
result[i.FreeHierItem_ID] = i;
}
return(result);
}
public bool LoadStaticChildren(bool isExistsParentRight, bool isHideTi = false, HashSet <long> selectedNodes = null,
int recursionNumber = 0, bool isLoadStatic = false)
{
//if (!IncludeObjectChildren)
//{
// // Эти объекты автоматически не подгружают дочерние объекты
// IsChildrenInitializet = true;
// return false;
//}
bool isExistsChildSeeDbObjects = false; //Наличие дочерних объектов которые явно имеют признак отображения
if (isExistsParentRight && HierObject != null && Descriptor.Tree_ID == GlobalFreeHierarchyDictionary.TreeTypeStandartSectionsNSI)
{
//Добавление констант
var hierarchyWithChildren = HierObject as IFreeHierarchyObjectWithChildren;
if (hierarchyWithChildren != null && hierarchyWithChildren.FormulaConstants != null && hierarchyWithChildren.FormulaConstants.Count > 0)
{
isExistsChildSeeDbObjects = true;
foreach (var formulaConstant in hierarchyWithChildren.FormulaConstants)
{
var formula = new FreeHierarchyTreeItem(Descriptor, formulaConstant, false, string.Empty, Descriptor.GetMinIdAndDecrement(), this, false,
freeHierItemType: EnumFreeHierarchyItemType.FormulaConstant, isChildrenInitializet: true);
//lock (_syncLock)
{
_children.Add(formula);
}
Descriptor.Tree.TryAdd(formula.FreeHierItem_ID, formula);
}
}
//if (Descriptor.TreeID == GlobalFreeHierarchyDictionary.TreeTypeStandartTIFormula)
//{
// if (IncludeChildrenFormulas(HierObject.Id, HierObject.Type, children)) isExistsChildSeeDbObjects = true;
// IncludeChildrenFormulaConstant();
//}
}
if (FreeHierItemType == EnumFreeHierarchyItemType.Error ||
FreeHierItemType == EnumFreeHierarchyItemType.Formula)
{
return(false);
}
if (_hierObject != null)
{
// Эти объекты автоматически не подгружают дочерние объекты
IsChildrenInitializet = IsChildrenInitializet ||
_hierObject.Type == enumTypeHierarchy.Dict_HierLev0
//|| _hierObject.Type == enumTypeHierarchy.Dict_HierLev1
//|| _hierObject.Type == enumTypeHierarchy.Dict_HierLev2
//|| _hierObject.Type == enumTypeHierarchy.Dict_HierLev3 //Перевел в динамическую подгрузку
//|| _hierObject.Type == enumTypeHierarchy.Info_TI
|| _hierObject.Type == enumTypeHierarchy.Formula ||
_hierObject.Type == enumTypeHierarchy.Formula_TP_OurSide ||
_hierObject.Type == enumTypeHierarchy.FormulaConstant;
}
return(isExistsChildSeeDbObjects);
}