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 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;
}
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);
}
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);
}
/// <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> 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);
}
/// <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);
}
/// <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 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);
}
/// <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);
}
public static IDictionary <int, FreeHierarchyTreeItem> GetTree(FreeHierarchyTreeDescriptor descriptor, out bool isFirstLoaded, bool isHideTi = false,
HashSet <long> selectedNodes = null, bool isFullReload = false, HashSet <int> singreRootFreeHierItemIds = null)
{
isFirstLoaded = false;
//Признак администратора
bool isUserAdmin = Manager.User.IsAdmin;
#if DEBUG
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
#endif
#region это стандартные деревья их не загружаем
switch (descriptor.Tree_ID)
{
//case TreeTypeStandartPS:
case TreeTypeStandartTIFormula:
case TreeTypeStandartDistributingArrangementAndBusSystem:
//if (isFullReload)
//{
// descriptor.UpdateIncludedObjectChildrenAsync(Manager.User.User_ID);
//}
return(GenerateStandartTreePS(descriptor, isHideTi));
case TreeTypeStandartSections:
case TreeTypeStandartSectionsNSI:
return(GenerateStandartTreeSections(descriptor));
case TreeTypeStandartBySupplyPS:
return(GenerateStandartTreeBySupplyPS(descriptor, isHideTi));
case TreeTypeStandartGroupTP:
return(JuridicalPersonTree.GenerateJuridicalPersonTree(descriptor, true, false));
case TreeTypeStandartJuridicalPerson:
return(JuridicalPersonTree.GenerateJuridicalPersonTree(descriptor, false, true));
case TreeTypeStandart_Dict_OPCUAServers:
return(GenerateStandartTree_Dict_OPCUAServers(descriptor));
case TreeTypeStandart_Dict_FIAS:
return(GenerateStandartTree_FIAS(false, descriptor));
case TreeTypeStandart_Dict_FIASToHierarchy:
return(GenerateStandartTree_FIAS(true, descriptor));
case TreeExplXmlExportConfigs:
return(GenerateExplXmlExportConfigsTree(descriptor));
case TreeExplXmlBalance63:
return(GenerateBalance63Tree(descriptor));
case TreeOldTelescope:
return(GenerateOldTelescopeTree(descriptor));
}
#endregion
var result = new ConcurrentDictionary <int, FreeHierarchyTreeItem>();
List <TFreeHierarchyTreeItem> tempList = null;
try
{
int?parenId = null;
if (singreRootFreeHierItemIds != null)
{
parenId = singreRootFreeHierItemIds.FirstOrDefault();
}
tempList = FreeHierarchyTreeDictionary.GetBranch(Manager.User.User_ID, descriptor.Tree_ID.GetValueOrDefault(), parenId,
isFullReload, onError: Manager.UI.ShowMessage);
}
catch (Exception ex)
{
Manager.UI.ShowMessage(ex.Message);
}
#if DEBUG
sw.Stop();
Console.WriteLine("Запрос дерева в БД {0} млс", sw.ElapsedMilliseconds);
sw.Restart();
#endif
if (tempList == null)
{
return(result);
}
FreeHierarchyTreePreparer.PrepareGlobalDictionaries(tempList);
if (descriptor != null)
{
descriptor.Tree = result;
}
foreach (var newItem in FreeHierarchyTreePreparer.BuildBranch(null, tempList, descriptor, isHideTi, selectedNodes))
{
result.TryAdd(newItem.FreeHierItem_ID, newItem);
}
//if ((uspdList!=null&&(uspdList.Count>0)))
//{
// ProcessUspdInTree(result,uspdList, isFilteredBySmallTi, isHideTi);
//}
#if DEBUG
sw.Stop();
Console.WriteLine("Построение дерева {0} млс", sw.ElapsedMilliseconds);
#endif
return(result);
}