Python tree.TreeNode类代码示例

    def new_storage_node(self, jail):
        storage_node = TreeNode()

        storage_node.gname = 'Storage'
        storage_node.name = _(u'Storage')
        storage_node.icon = u'JailStorageIcon'

        return storage_node

    def new_jail_node(self, jail, icon=u'JailIcon'):
        jail_node = TreeNode()

        jail_node.gname = jail.jail_host
        jail_node.name = jail.jail_host
        jail_node.icon = icon

        return jail_node

    def new_storage_node_view(self, nmp):
        storage_node_view = TreeNode()

        storage_node_view.name = nmp.destination
        storage_node_view.gname = nmp.id
        storage_node_view.type = 'editobject'
        storage_node_view.view = 'freeadmin_jails_jailmountpoint_edit'
        storage_node_view.kwargs = {'oid': nmp.id}
        storage_node_view.model = 'JailMountPoint'
        storage_node_view.icon = u'SettingsIcon'
        storage_node_view.app_name = 'jails'

        return storage_node_view

    def new_storage_node_add(self, jail):
        storage_node_add = TreeNode()

        storage_node_add.name = _('Add Storage')
        storage_node_add.gname = 'Add'
        storage_node_add.type = 'editobject'
        storage_node_add.view = 'jail_storage_add'
        storage_node_add.kwargs = {'jail_id': jail.id}
        storage_node_add.model = 'JailMountPoint'
        storage_node_add.icon = u'JailStorageIcon'
        storage_node_add.app_name = 'jails'

        return storage_node_add

    def new_jail_node_view(self, jail):
        jail_node_view = TreeNode()

        jail_node_view.name = _('Edit')
        jail_node_view.gname = 'Edit'
        jail_node_view.type = 'editobject'
        jail_node_view.view = 'jail_edit'
        jail_node_view.kwargs = {'id': jail.id}
        jail_node_view.model = 'Jails'
        jail_node_view.icon = u'SettingsIcon'
        jail_node_view.app_name = 'jails'

        return jail_node_view

    def new_storage_node_view(self, nmp):
        storage_node_view = TreeNode()

        storage_node_view.name = _('%s' % nmp.destination)
        storage_node_view.type = 'editobject'
        storage_node_view.view = 'jail_storage_view'
        storage_node_view.kwargs = { 'id': nmp.id }
        storage_node_view.model = 'NullMountPoint'
        storage_node_view.icon = u'SettingsIcon'
        storage_node_view.app_name = 'jails' 

        return storage_node_view

    def __init__(self, *args, **kwargs):
        super(AdminAccount, self).__init__(*args, **kwargs)

        chpw = TreeNode('ChangePass')
        chpw.name = _('Change Password')
        chpw.type = 'openaccount'
        chpw.icon = u'ChangePasswordIcon'

        chad = TreeNode('ChangeAdmin')
        chad.name = _('Change Admin User')
        chad.type = 'openaccount'
        chad.icon = u'ChangeAdminIcon'
        self.append_children([chpw, chad])

    def new_activedirectory_node(self):
        ad_node = TreeNode("Active Directory")

        ad_node.name = 'Active Directory'
        ad_node.app_name = 'activedirectory'
        ad_node.icon = u'ActiveDirectoryIcon'

        try:
            ad = ActiveDirectory.objects.order_by("-id")[0]
            ad_node.kwargs = {'oid': ad.id}
            ad_node.type = 'editobject'
            ad_node.view = 'freeadmin_services_activedirectory_edit'

        except IndexError:
            ad_node.type = 'object'
            ad_node.view = 'freeadmin_services_activedirectory_add'

        return ad_node

    def new_domaincontroller_node(self):
        ad_node = TreeNode("Domain Controller")

        ad_node.name = 'Domain Controller'
        ad_node.app_name = 'domaincontroller'
        ad_node.icon = u'DomainControllerIcon'

        try:
            ad = DomainController.objects.order_by("-id")[0]
            ad_node.kwargs = {'oid': ad.id}
            ad_node.type = 'editobject'
            ad_node.view = 'freeadmin_services_domaincontroller_edit'

        except IndexError:
            ad_node.type = 'object'
            ad_node.view = 'freeadmin_services_domaincontroller_add'

        return ad_node

    def new_ldap_node(self):
        ldap_node = TreeNode("LDAP")

        ldap_node.name = 'LDAP'
        ldap_node.app_name = 'ldap'
        ldap_node.icon = u'LDAPIcon'

        try:
            ldap = LDAP.objects.order_by("-id")[0]
            ldap_node.kwargs = {'oid': ldap.id}
            ldap_node.type = 'editobject'
            ldap_node.view = 'freeadmin_services_ldap_edit'

        except IndexError:
            ldap_node.type = 'object'
            ldap_node.view = 'freeadmin_services_ldap_add'

        return ldap_node

    def new_nis_node(self):
        nis_node = TreeNode("NIS")

        nis_node.name = 'NIS'
        nis_node.app_name = 'nis'
        nis_node.icon = u'NISIcon'

        try:
            nis = NIS.objects.order_by("-id")[0]
            nis_node.kwargs = {'oid': nis.id}
            nis_node.type = 'editobject'
            nis_node.view = 'freeadmin_services_nis_edit'

        except IndexError:
            nis_node.type = 'object'
            nis_node.view = 'freeadmin_services_nis_add'

        return nis_node

    def new_nt4_node(self):
        nt4_node = TreeNode("NT4")

        nt4_node.name = 'NT4'
        nt4_node.app_name = 'nt4'
        nt4_node.icon = u'NT4Icon'

        try:
            nt4 = NT4.objects.order_by("-id")[0]
            nt4_node.kwargs = {'oid': nt4.id}
            nt4_node.type = 'editobject'
            nt4_node.view = 'freeadmin_services_nt4_edit'

        except IndexError:
            nt4_node.type = 'object'
            nt4_node.view = 'freeadmin_services_nt4_add'

        return nt4_node

    def new_storage_node_mkdir(self, jail):
        storage_node_add = TreeNode()

        storage_node_add.name = _('Make Directory')
        storage_node_add.type = 'editobject'
        storage_node_add.view = 'jail_mkdir'
        storage_node_add.kwargs = { 'id': jail.id }
        storage_node_add.icon = u'JailMkdirIcon'
        storage_node_add.app_name = 'jails' 

        return storage_node_add 

    def _generate_app(self, app, request, tree_roots, childs_of):

        # Thats the root node for the app tree menu
        nav = TreeRoot(app.split(".")[-1])

        modnav = self._get_module(app, 'nav')
        if hasattr(modnav, 'BLACKLIST'):
            BLACKLIST = modnav.BLACKLIST
        else:
            BLACKLIST = []

        if hasattr(modnav, 'ICON'):
            nav.icon = modnav.ICON

        if hasattr(modnav, 'NAME'):
            nav.name = modnav.NAME
        else:
            nav.name = self.titlecase(app)

        if hasattr(modnav, 'TYPE'):
            nav.type = modnav.TYPE

        if hasattr(modnav, 'HIDE'):
            nav.skip = modnav.HIDE

        if hasattr(modnav, 'URL'):
            nav.url = reverse(modnav.URL)

        if modnav:
            modname = "%s.nav" % app
            for c in dir(modnav):
                navc = getattr(modnav, c)
                try:
                    subclass = issubclass(navc, TreeNode)
                except TypeError:
                    continue
                if navc.__module__ == modname and subclass:
                    obj = navc(request=request)

                    if obj.skip is True:
                        continue
                    if not obj.append_to:
                        self.register_option(obj, nav, replace=True)
                    else:
                        self._navs[obj.append_to + '.' + obj.gname] = obj

            tree_roots.register(nav)  # We register it to the tree root
            if hasattr(modnav, 'init'):
                modnav.init(tree_roots, nav, request)
            appPool.hook_nav_init(nav.gname, tree_roots, nav, request)

        else:
            log.debug("App %s has no nav.py module, skipping", app)
            return

        modmodels = self._get_module(app, 'models')
        if modmodels:

            modname = '%s.models' % app
            for c in dir(modmodels):

                model = getattr(modmodels, c)
                try:
                    if issubclass(model, models.Model):
                        if model._meta.app_label == app:
                            continue
                    else:
                        continue
                except TypeError, e:
                    continue

                if c in BLACKLIST:
                    log.debug(
                        "Model %s from app %s blacklisted, skipping",
                        c,
                        app,
                    )
                    continue

                if not (
                    model.__module__ in (
                        modname,
                        'freenasUI.' + modname,
                    )
                    and
                    model in self._modelforms
                ):
                    log.debug("Model %s does not have a ModelForm", model)
                    continue

                if model._admin.deletable is False:
                    navopt = TreeNode(
                        str(model._meta.object_name),
                        name=model._meta.verbose_name,
                        model=c, app_name=app, type='dialog')
                    try:
                        navopt.kwargs = {
                            'oid': model.objects.order_by("-id")[0].id,
                        }
                        navopt.view = 'freeadmin_%s_%s_edit' % (
#.........这里部分代码省略.........

    def __init__(self, *args, **kwargs):
        super(ViewPluginJails, self).__init__(*args, **kwargs)
        request = kwargs.get('request')

        host = get_base_url(request)
        jails = Jails.objects.filter(jail_type=WARDEN_TYPE_PLUGINJAIL)
        for jail in jails:
            jail_node = self.new_jail_node(jail, u'JailPluginIcon')
            self.append_child(jail_node)

            jail_node_view = self.new_jail_node_view(jail)
            jail_node_view.order = 1
            jail_node.append_child(jail_node_view)

            storage_node = self.new_storage_node(jail)
            storage_node.order = 2
            jail_node.append_child(storage_node)

            storage_order = 1
            nmps = NullMountPoint.objects.filter(jail=jail.jail_host)
            for nmp in nmps:
                storage_node_view = self.new_storage_node_view(nmp)
                storage_node_view.order = storage_order
                storage_node.append_child(storage_node_view)
                storage_order += 1

            storage_node_mkdir = self.new_storage_node_mkdir(jail)
            storage_node_mkdir.order = storage_order
            storage_node.append_child(storage_node_mkdir)
            storage_order += 1

            storage_node_add = self.new_storage_node_add(jail)
            storage_node_add.order = storage_order
            storage_node.append_child(storage_node_add)

            plugin_node = TreeNode()
            plugin_node.gname = 'Plugins'
            plugin_node.name = _(u'Plugins')
            plugin_node.icon = u'PluginIcon'
            plugin_node.order = 3

            args = map(
                lambda y: (y, host, request),
                Plugins.objects.filter(plugin_enabled=True, plugin_jail=jail.jail_host))

            plugin_order = 1
            pool = eventlet.GreenPool(20)
            for plugin, url, data in pool.imap(self.plugin_fetch, args):
                if not data:
                    continue

                try:
                    data = simplejson.loads(data)
                    nodes = unserialize_tree(data)
                    for node in nodes:
                        node.order = plugin_order 
                        plugin_node.append_child(node) 
                        plugin_order += 1

                except Exception, e:
                    log.warn(_(
                         "An error occurred while unserializing from "
                        "%(url)s: %(error)s") % {'url': url, 'error': e})
                    log.debug(_(
                        "Error unserializing %(url)s (%(error)s), data "
                        "retrieved:") % {
                            'url': url,
                            'error': e,
                        })
                    for line in data.splitlines():
                        log.debug(line)

                continue

            plugin_node_add = TreeNode()
            plugin_node_add.name = _('Install Plugin')
            plugin_node_add.type = 'editobject'
            plugin_node_add.view = 'plugin_install'
            plugin_node_add.kwargs = {'jail_id': jail.id }
            plugin_node_add.model = 'Plugins'
            plugin_node_add.icon = u'PluginInstallIcon'
            plugin_node_add.app_name = 'jails' 
            plugin_node_add.order = plugin_order

            plugin_node.append_child(plugin_node_add)

            jail_node.append_child(plugin_node)