def insertIntoBST(self, root, val):
"""
:type root: TreeNode
:type val: int
:rtype: TreeNode
"""
if not root:
return TreeNode(val)
parent = None
node = root
while node:
if node.val == val:
return root
if node.val < val:
parent = node
node = node.right
else:
parent = node
node = node.left
if parent.val < val:
parent.right = TreeNode(val)
else:
parent.left = TreeNode(val)
return root
def createTreeNode(dataSet, featureNames):
"""创建决策树节点"""
# 获取当前数据集中的所有标签
labels = [item[-1] for item in dataSet]
# 过滤重复标签
uniqueLabels = set(labels)
# 如果当前数据集中标签都一样返回叶子节点
if len(uniqueLabels) == 1:
return TreeNode(label=labels[0])
# 如果当前数据集中所有数据特征相同，返回叶子节点
if DecisionTree.isAllItemIdentical(dataSet):
# 叶子节点标签取主要的标签（出现次数最多的标签）
majorLabel = DecisionTree.majorLabel(labels)
return TreeNode(label=majorLabel)
# 选择一个最佳的划分特征
bestFeature = DecisionTree.chooseBestSplitFeature(dataSet)
bestFeatureName = featureNames[bestFeature]
featureNames.pop(bestFeature)
children = {}
# 获取划分特征的所有可能值
featureValues = set([item[bestFeature] for item in dataSet])
# 遍历特征的所有值
for value in featureValues:
# 使用该值划分子数据集
subDataSet = DecisionTree.splitDataSet(dataSet, bestFeature, value)
# 继续根据子数据集创建决策树节点
children[value] = DecisionTree.createTreeNode(
subDataSet, featureNames[:])
# 返回树节点
return TreeNode(label=bestFeatureName, children=children)
def addOneRow(self, root, v, d):
"""
:type root: TreeNode
:type v: int
:type d: int
:rtype: TreeNode
"""
if d == 1:
newRoot = TreeNode(v)
newRoot.left = root
return newRoot
curRowNodes = [root]
while d != 2:
childNodes = []
for node in curRowNodes:
if node.left:
childNodes.append(node.left)
if node.right:
childNodes.append(node.right)
d -= 1
curRowNodes = childNodes
for node in curRowNodes:
left = TreeNode(v)
right = TreeNode(v)
left.left = node.left
right.right = node.right
node.left = left
node.right = right
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
if len(nums) == 1:
return TreeNode(nums[0])
if len(nums) == 2:
return TreeNode(nums[1], TreeNode(nums[0]))
rootIdx = len(nums) // 2
return TreeNode(nums[rootIdx], self.sortedArrayToBST(nums[:rootIdx]),
self.sortedArrayToBST(nums[rootIdx + 1:]))
def dfs(left, right):
if left < 0 or left >= len(nums) or left > right:
return
index = left
maxIndex = left
while index <= right:
if nums[index] > nums[maxIndex]:
maxIndex = index
index += 1
node = TreeNode(nums[maxIndex])
node.left = dfs(left, maxIndex - 1)
node.right = dfs(maxIndex + 1, right)
return node
def as_tree_node(self, pid):
icon_skin_category_mapper = {
'remote_app': 'chrome',
'db': 'database',
'cloud': 'cloud'
}
icon_skin = icon_skin_category_mapper.get(self.category, 'file')
node = TreeNode(
**{
'id': str(self.id),
'name': self.name,
'title': self.name,
'pId': pid,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'meta': {
'type': 'application',
'data': {
'category': self.category,
'type': self.type,
}
}
})
return node
def create_tree_node(id_,
pid,
name,
identity,
parent_info,
icon='',
is_container=False):
node = TreeNode(
**{
'id': id_,
'name': name,
'title': name,
'pId': pid,
'isParent': not is_container,
'open': False,
'iconSkin': icon,
'parentInfo': urlencode(parent_info),
'meta': {
'type': 'application',
'data': {
'category': const.AppCategory.cloud,
'type': const.AppType.k8s,
'identity': identity
}
}
})
return node
def parse_asset_to_tree_node(node, asset, system_users):
system_users_protocol_matched = [
s for s in system_users if s.protocol == asset.protocol
]
system_user_serializer = serializers.GrantedSystemUserSerializer(
system_users_protocol_matched, many=True)
asset_serializer = serializers.GrantedAssetSerializer(asset)
icon_skin = 'file'
if asset.platform.lower() == 'windows':
icon_skin = 'windows'
elif asset.platform.lower() == 'linux':
icon_skin = 'linux'
data = {
'id': str(asset.id),
'name': asset.hostname,
'title': asset.ip,
'pId': node.key,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'meta': {
'system_users': system_user_serializer.data,
'type': 'asset',
'asset': asset_serializer.data
}
}
tree_node = TreeNode(**data)
return tree_node
def create_choice_node(cls,
c,
id_,
pid,
tp,
opened=False,
counts=None,
show_empty=True,
show_count=True):
count = counts.get(c.value, 0)
if count == 0 and not show_empty:
return None
label = c.label
if count is not None and show_count:
label = '{} ({})'.format(label, count)
data = {
'id': id_,
'name': label,
'title': label,
'pId': pid,
'isParent': bool(count),
'open': opened,
'iconSkin': '',
'meta': {
'type': tp,
'data': {
'name': c.name,
'value': c.value
}
}
}
return TreeNode(**data)
def _create_node(self,
data,
tp,
is_parent=True,
is_open=True,
icon='',
checked=None):
assert data.get('id')
assert data.get('name')
assert data.get('pId') is not None
node_data = {
'isParent': is_parent,
'iconSkin': icon,
'open': is_open,
'chkDisabled': self.check_disabled,
'checked': checked,
'meta': {
'type': tp,
},
**data
}
node_data['title'] = node_data['id']
node = TreeNode(**node_data)
if DEBUG_DB:
node.name += ('[' + node.id + ']')
if DEBUG_DB:
node.name += ('-' + node.id)
return node
def parse_asset_to_tree_node(node, asset):
icon_skin = 'file'
platform = asset.platform_base.lower()
if platform == 'windows':
icon_skin = 'windows'
elif platform == 'linux':
icon_skin = 'linux'
parent_id = node.key if node else ''
data = {
'id': str(asset.id),
'name': asset.hostname,
'title': asset.ip,
'pId': parent_id,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'nocheck': not asset.has_protocol('ssh'),
'meta': {
'type': 'asset',
'asset': {
'id': asset.id,
'hostname': asset.hostname,
'ip': asset.ip,
'protocols': asset.protocols_as_list,
'platform': asset.platform_base,
'domain': asset.domain_id,
'org_name': asset.org_name,
},
}
}
tree_node = TreeNode(**data)
return tree_node
def as_tree_node(self, parent_node):
from common.tree import TreeNode
icon_skin = 'file'
if self.platform.lower() == 'windows':
icon_skin = 'windows'
elif self.platform.lower() == 'linux':
icon_skin = 'linux'
data = {
'id': str(self.id),
'name': self.hostname,
'title': self.ip,
'pId': parent_node.key,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'meta': {
'type': 'asset',
'asset': {
'id': self.id,
'hostname': self.hostname,
'ip': self.ip,
'protocols': self.protocols_as_list,
'platform': self.platform,
}
}
}
tree_node = TreeNode(**data)
return tree_node
def createFileTree(treename, rootname, only_files, only_dirs):
from common.tree import Tree, TreeNode
tree = Tree(TreeNode(rootname), treename)
for only_file in only_files:
addFilePathToTree(only_file, tree)
for dir in only_dirs:
addFilePathToTree(dir, tree)
return tree
def helper(preIndex, postSt, postEnd):
if preIndex == len(pre):
return None
if postSt == postEnd:
return TreeNode(post[postEnd])
node = TreeNode(pre[preIndex])
if preIndex == len(pre) - 1:
return node
childNum = pre[preIndex + 1]
index = postSt
while index < postEnd:
if post[index] == childNum:
break
index += 1
if index == postEnd:
print("wrong!")
if index == postEnd - 1:
node.right = None
node.left = helper(preIndex + 1, postSt, postEnd - 1)
else:
node.left = helper(preIndex + 1, postSt, index)
node.right = helper(preIndex + 2 + index - postSt, index + 1,
postEnd - 1)
return node
def flatten(self, root: TreeNode) -> None:
"""
Do not return anything, modify root in-place instead.
"""
if not root:
return
if root.right:
self.flatten(root.right)
if root.left:
self.flatten(root.left)
curNode = root.left
while curNode.right:
curNode = curNode.right
curNode.right = root.right
root.right = root.left
root.left = None
def parse_asset_to_tree_node(node, asset, system_users):
system_users_protocol_matched = [
s for s in system_users if s.protocol == asset.protocol
]
icon_skin = 'file'
if asset.platform.lower() == 'windows':
icon_skin = 'windows'
elif asset.platform.lower() == 'linux':
icon_skin = 'linux'
system_users = []
for system_user in system_users_protocol_matched:
system_users.append({
'id':
system_user.id,
'name':
system_user.name,
'username':
system_user.username,
'protocol':
system_user.protocol,
'priority':
system_user.priority,
'login_mode':
system_user.login_mode,
'actions': [action.name for action in system_user.actions],
'comment':
system_user.comment,
})
data = {
'id': str(asset.id),
'name': asset.hostname,
'title': asset.ip,
'pId': node.key,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'meta': {
'system_users': system_users,
'type': 'asset',
'asset': {
'id': asset.id,
'hostname': asset.hostname,
'ip': asset.ip,
'port': asset.port,
'protocol': asset.protocol,
'platform': asset.platform,
'domain': None if not asset.domain else asset.domain.id,
'is_active': asset.is_active,
'comment': asset.comment
},
}
}
tree_node = TreeNode(**data)
return tree_node
def construct_database_apps_tree_root():
tree_root = {
'id': 'ID_DATABASE_APP_ROOT',
'name': 'DatabaseApp',
'title': 'DatabaseApp',
'pId': '',
'open': False,
'isParent': True,
'iconSkin': '',
'meta': {'type': 'database_app'}
}
return TreeNode(**tree_root)
def construct_remote_apps_tree_root(amount):
tree_root = {
'id': 'ID_REMOTE_APP_ROOT',
'name': '{} ({})'.format(_('RemoteApp'), amount),
'title': 'RemoteApp',
'pId': '',
'open': False,
'isParent': True,
'iconSkin': '',
'meta': {'type': 'remote_app'}
}
return TreeNode(**tree_root)
def construct_k8s_apps_tree_root():
tree_root = {
'id': 'ID_K8S_APP_ROOT',
'name': _('KubernetesApp'),
'title': 'K8sApp',
'pId': '',
'open': False,
'isParent': True,
'iconSkin': '',
'meta': {'type': 'k8s_app'}
}
return TreeNode(**tree_root)
def parse_database_app_to_tree_node(parent, database_app):
pid = parent.id if parent else ''
tree_node = {
'id': database_app.id,
'name': database_app.name,
'title': database_app.name,
'pId': pid,
'open': False,
'isParent': False,
'iconSkin': 'file',
'meta': {'type': 'database_app'}
}
return TreeNode(**tree_node)
def as_tree_node(self, oid, pid, opened=True):
node = TreeNode(**{
'id': oid,
'name': self.name,
'title': self.name,
'pId': pid,
'open': opened,
'isParent': True,
'meta': {
'type': 'org'
}
})
return node
def create_root_node():
name = _('My applications')
node = TreeNode(**{
'id': 'applications',
'name': name,
'title': name,
'pId': '',
'open': True,
'isParent': True,
'meta': {
'type': 'root'
}
})
return node
def parse_remote_app_to_tree_node(parent, remote_app):
tree_node = {
'id': remote_app.id,
'name': remote_app.name,
'title': remote_app.name,
'pId': parent.id,
'open': False,
'isParent': False,
'iconSkin': 'file',
'meta': {
'type': 'remote_app'
}
}
return TreeNode(**tree_node)
def addFilePathToTree(self, file):
from common.tree import TreeNode
filestrarr = file.split("/")
filestrarr = [file for file in filestrarr if file.strip() != ""]
pathNode = self.root
for pathfile in filestrarr:
if pathNode:
childNode = pathNode.get_child(pathfile)
if childNode is None:
newNode = TreeNode(pathfile)
pathNode.add_child(newNode)
pathNode = newNode
else:
pathNode = childNode
def _create_perms_nodes(self):
permissions_id = self.permissions.values_list('id', flat=True)
nodes = []
content_types = ContentType.objects.all()
content_types_name_mapper = {
ct.app_model: ct.name
for ct in content_types
}
for p in self.all_permissions:
model_id = f'{p.app}.{p.model}'
if not self._check_model_xpack(model_id):
continue
title = p.app_label_codename
if not settings.XPACK_ENABLED and title in xpack_nodes:
continue
# name 要特殊处理，解决 i18n 问题
name, icon = self._get_permission_name_icon(
p, content_types_name_mapper)
if DEBUG_DB:
name += '[{}]'.format(p.app_label_codename)
pid = model_id
# perm node 的特殊设置用的是 title，因为 id 是数字，不一致
if title in special_pid_mapper:
pid = special_pid_mapper[title]
self.total_counts[pid] += 1
checked = p.id in permissions_id
if checked:
self.checked_counts[pid] += 1
node = TreeNode(
**{
'id': p.id,
'name': name,
'title': title,
'pId': pid,
'isParent': False,
'chkDisabled': self.check_disabled,
'iconSkin': icon,
'checked': p.id in permissions_id,
'open': False,
'meta': {
'type': 'perm',
}
})
nodes.append(node)
return nodes
def create_empty_node():
name = _("Empty")
node = TreeNode(
**{
'id': 'empty',
'name': name,
'title': name,
'pId': '',
'isParent': True,
'children': [],
'meta': {
'type': 'application'
}
})
return node
def increasingBST(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
temp = TreeNode('0')
previous = temp
queue = []
cur = root
preright = None
while cur or queue:
pass
return temp.right
def parse_node_to_tree_node(node):
name = '{} ({})'.format(node.value, node.assets_amount)
node_serializer = serializers.GrantedNodeSerializer(node)
data = {
'id': node.key,
'name': name,
'title': name,
'pId': node.parent_key,
'isParent': True,
'open': node.is_root(),
'meta': {
'node': node_serializer.data,
'type': 'node'
}
}
tree_node = TreeNode(**data)
return tree_node
def parse_asset_to_tree_node(node, asset, system_users):
icon_skin = 'file'
if asset.platform.lower() == 'windows':
icon_skin = 'windows'
elif asset.platform.lower() == 'linux':
icon_skin = 'linux'
_system_users = []
for system_user in system_users:
_system_users.append({
'id':
system_user.id,
'name':
system_user.name,
'username':
system_user.username,
'protocol':
system_user.protocol,
'priority':
system_user.priority,
'login_mode':
system_user.login_mode,
'actions': [Action.value_to_choices(system_user.actions)],
})
data = {
'id': str(asset.id),
'name': asset.hostname,
'title': asset.ip,
'pId': node.key,
'isParent': False,
'open': False,
'iconSkin': icon_skin,
'meta': {
'system_users': _system_users,
'type': 'asset',
'asset': {
'id': asset.id,
'hostname': asset.hostname,
'ip': asset.ip,
'protocols': asset.protocols_as_list,
'platform': asset.platform,
},
}
}
tree_node = TreeNode(**data)
return tree_node
def as_tree_node(self):
from common.tree import TreeNode
from ..serializers import NodeSerializer
name = '{} ({})'.format(self.value, self.assets_amount)
node_serializer = NodeSerializer(instance=self)
data = {
'id': self.key,
'name': name,
'title': name,
'pId': self.parent_key,
'isParent': True,
'open': self.is_root(),
'meta': {
'node': node_serializer.data,
'type': 'node'
}
}
tree_node = TreeNode(**data)
return tree_node
