gmcm-django-superadmin 2.2.0__py3-none-any.whl

gmcm_django_superadmin-2.2.0.dist-info/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2020, Denis Siavichay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

gmcm_django_superadmin-2.2.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: gmcm-django-superadmin
+Version: 2.2.0
+Summary: A Django app for build admin sites like django admin.
+Home-page: https://gitlab.com/mmorona/gmcm-django-superadmin
+Author: Denis Siavichay
+Author-email: dbsiavichay@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: Django>=3.2
+Requires-Dist: pyyaml
+
+Superadmin
+=====
+
+Superadmin is a Django app based in django admin to build admin sites quickly and easily, and generate site page like django admin.
+
+Detailed documentation is in the "docs" directory.
+
+Quick start
+-----------
+
+1. Add "superadmin" to your INSTALLED_APPS setting like this::
+
+    INSTALLED_APPS = [
+        ...
+        'superadmin',
+    ]
+
+3. Run ``python manage.py migrate`` to create the superadmin migrations.
+
+4. Continue

gmcm_django_superadmin-2.2.0.dist-info/RECORD

@@ -0,0 +1,54 @@
+superadmin/__init__.py,sha256=xY_ZGbpqe8k2Gnbzp3zoJhICotPGaVatPcmNHpfhmO8,288
+superadmin/admin.py,sha256=jLBfNlcrVGhi-kboYcYfPecMH_jI5O9soaN3KtjDLnA,1297
+superadmin/apps.py,sha256=umBpp6E-RYaIxdIN9Z2ZUwu4dJr7cmrpKGxBKo8oInc,263
+superadmin/checks.py,sha256=sJj9FTQ1Ra_vN9MA6JbPODwa1DOrU96v9NWbD9HAt_Y,1590
+superadmin/context_processors.py,sha256=IZydf6pEaH5dCDZrSRxrp9bZAt6sKJPYdVMwrJIVPdY,1750
+superadmin/decorators.py,sha256=b0uNNMuCR3nnbxgYhI-F3WlMqVKUHo4RNGXG2I5SmaA,1029
+superadmin/forms.py,sha256=Kxr8JCjC2PQtK-NM7ef6qkQ8CwdQtudeqCLXJvdM6No,2239
+superadmin/models.py,sha256=LjGVmE0O7NfwUog7pTJXINUCUgqeMlbOpOoo_wQUghU,4889
+superadmin/options.py,sha256=cpsaW_n-ADU-rieBPIP8U1hkxX6osDluOyfeNE70Udg,10831
+superadmin/services.py,sha256=l9UHXNNaTWm_mD5v6PHpPC05yTs1qK2d6Zly8FCzdXA,11726
+superadmin/settings.py,sha256=JscpGBTwCIaunP-R1bxle6TV-cZemgWKTNtAeGr_Ab0,1427
+superadmin/shortcuts.py,sha256=FQaZ_8HN_CyyiGjcPurixhepAzFK48m8HGH2O8phbGE,2141
+superadmin/signals.py,sha256=mfKBYjA5IOvUrnrwkGpTP5r9fURjvyWR_ZxWoEdorsc,2140
+superadmin/sites.py,sha256=K-ufuO8DR4cVr3mgGYso3wCyM0SIjom1M3GRcewWBUU,5794
+superadmin/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
+superadmin/utils.py,sha256=Qo3_I2YnSa2cOcf00qvArb8-1j5A-ZWe-XZgUl2rYkE,1971
+superadmin/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+superadmin/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+superadmin/management/commands/base.py,sha256=uUike50nua9MvGqqS_YakCNQ3adhOR86W0zb5zswItM,4454
+superadmin/management/commands/createactions.py,sha256=ESOhhP7LaAoM-MrcNFmQ4g7vWo91TBUegM0hgpmw2eU,340
+superadmin/management/commands/createbasemenu.py,sha256=_0bToDMIU8vbskPPsA1VbNswrTDOq5MQcxRF6oXCnUY,1606
+superadmin/management/commands/createpermission.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+superadmin/management/commands/menu.py,sha256=165h7E5lX8EsD7DNX0f5m7Sjw3HvDN81rtU4_FNVzAA,1183
+superadmin/migrations/0001_action_menu.py,sha256=ZlpbYuujXZ8o2bw0HYYMJcSFx2YDJry1D20N0TGkmFY,4350
+superadmin/migrations/0002_auto_20211106_0726.py,sha256=LQ5DHhZCOyvfv4PiBvrtD8C2wvZYJALVCJjDBGXY0zM,345
+superadmin/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+superadmin/migrations/unaccent_extension.py,sha256=EC5U9eVnqrjvms0oHfxclqytxLJKhrn4lj90Doi8Pus,227
+superadmin/mixins/__init__.py,sha256=TkKqewDJOq065DsCIiaNFkZiibMFTkm80AXgUjA6fIM,221
+superadmin/mixins/breadcrumbs.py,sha256=RKesyhkQSLehJcNW3zWHO31LGUJHK6j6hne66FcSuFM,3200
+superadmin/mixins/filters.py,sha256=pbtszUEB9hYuqpId8zFegmOxaGRGEK1WsD4zzBF-Nzc,3666
+superadmin/mixins/inlines.py,sha256=n-ffyn5Mv50ombBXRpkLX_51qe3KECgXq_RHWnHgCrk,2928
+superadmin/mixins/permissions.py,sha256=WCLYXv9gS1WKA4zzCqG2hOzTIyu1u-8bx64IwTY9yd4,1784
+superadmin/mixins/templates.py,sha256=L2MZ4MvXcNgHxDVBCmIN_pl7yQA_3MqsSBnWfF4wju0,234
+superadmin/mixins/urls.py,sha256=s2M5Xe4kh0hv7EuMdC0UtW7MoA7s3j2V6O3bGukLrUo,517
+superadmin/mixins/utils.py,sha256=mL4sAwYzYRKxbj4RftPHReXfku3ZO45xaZZhxxcTVgE,1205
+superadmin/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+superadmin/templatetags/superadmin_forms.py,sha256=DWfEc2T6ECzGz7VuFCObpUhAQDTSPY3xq5_F2tiJ9Rs,14325
+superadmin/templatetags/superadmin_utils.py,sha256=46oAASKfQNtoWi-oy_UcSDv37QM7z_nkcNasKQxXHlg,1676
+superadmin/views/__init__.py,sha256=V2GwZb5ZBCZ03OEGMOYLppvTQKkT6Vf_xZS9Pz0apPA,401
+superadmin/views/base.py,sha256=YvZRqJd7QUb2kJaY5By73Yco0ug9Cm7TkFJfh4G7iyw,2843
+superadmin/views/create.py,sha256=i48oqCCRu5O3dkNUmARK3K981KbkAwnX3uortzxEG3I,3944
+superadmin/views/delete.py,sha256=qqMcItsBukRn2ktQF0N_vHMzI6XAPlZ7oWcreOX-cMc,2643
+superadmin/views/detail.py,sha256=ncvI7bbjJGsGQO2PL5NV23M3w00Gq77nFgamsJjU9x8,4598
+superadmin/views/duplicate.py,sha256=O1Ug4BqNPPD1K7va4lXu6gACRLPSas3ZfoQNkJ6u63k,459
+superadmin/views/export.py,sha256=J_Ccj70kNtvluN6iCP1yjKI0eSinZ19xGVpyiw1ruZk,3117
+superadmin/views/filter.py,sha256=XcvAo2JgXZOSyGU8LO5gYcFpzdU6smnFdNG3VlrDZY0,3915
+superadmin/views/filtering.py,sha256=JiG504RnbS_dbWvMYlftTpBxMegguhZwEP1242rcsbU,11123
+superadmin/views/list.py,sha256=w3DXKpmBcGnlMIMFOP_OgcUCKfQpRkg5zg3AyO2Ji6M,6108
+superadmin/views/update.py,sha256=RHtzOxS2ONz1ytfl_5YgMYrmuVpzefeJ3X9uM-Vt4sw,4603
+gmcm_django_superadmin-2.2.0.dist-info/LICENCE,sha256=vq6PaqQ09rc6JhaJG-B76D2YSnTKzvaDkOsU8zmdWDk,1059
+gmcm_django_superadmin-2.2.0.dist-info/METADATA,sha256=jSt2NPBAY-FTu3sRrC-qz1Y5UH8SgaYs2ByOx3LCSwQ,1716
+gmcm_django_superadmin-2.2.0.dist-info/WHEEL,sha256=OpXWERl2xLPRHTvd2ZXo_iluPEQd8uSbYkJ53NAER_Y,109
+gmcm_django_superadmin-2.2.0.dist-info/top_level.txt,sha256=EPWyLOWlKsTG6m9K_ksHGTV1b_j9Rv51T_lmcYjZMJI,11
+gmcm_django_superadmin-2.2.0.dist-info/RECORD,,

gmcm_django_superadmin-2.2.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

gmcm_django_superadmin-2.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+superadmin

superadmin/__init__.py

@@ -0,0 +1,12 @@
+""" Hydra init config """
+from .sites import site
+from .options import ModelSite
+from django.utils.module_loading import autodiscover_modules
+
+__all__ = ["site", "ModelSite"]
+
+default_app_config = "superadmin.apps.SuperAdminConfig"
+
+
+def autodiscover():
+    autodiscover_modules("sites")

superadmin/admin.py

@@ -0,0 +1,46 @@
+""" Hydra model admin """
+
+"""
+
+# Django
+from django.contrib import admin
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+
+# Models
+from hydra.models import Action, Menu
+
+# Forms
+from hydra.forms import BaseActionForm, BaseMenuForm, BasePermissionForm
+
+@admin.register(Action)
+class ActionAdmin(admin.ModelAdmin):
+    form = BaseActionForm
+    list_display = ("__str__", "app_label")
+
+
+@admin.register(Menu)
+class MenuAdmin(admin.ModelAdmin):
+    form = BaseMenuForm
+    list_display = ('__str__', 'action',)
+
+
+@admin.register(Permission)
+class PermisionAdmin(admin.ModelAdmin):
+    model = Permission
+    form = BasePermissionForm
+    list_display = ("name", "codename", "__str__")
+
+    def __init__(self, model, admin_site):
+        self.model._meta.verbose_name = "permiso específico"
+        self.model._meta.verbose_name_plural = "permisos específicos"
+        super().__init__(model, admin_site)
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        ct = ContentType.objects.get_for_model(self.model)
+        codenames = ("add_permission","change_permission","delete_permission","view_permission")
+        qs = qs.filter(content_type=ct).exclude(codename__in=codenames)
+        return qs
+
+"""

superadmin/apps.py

@@ -0,0 +1,14 @@
+""" Hydra Apps config  """
+
+# Django
+from django.apps import AppConfig
+
+
+class SuperAdminConfig(AppConfig):
+    name = "superadmin"
+
+    def ready(self):
+        from . import signals
+        from . import checks  # noqa: F401
+
+        self.module.autodiscover()

superadmin/checks.py

@@ -0,0 +1,45 @@
+"""System checks that validate ModelSite field configuration at startup.
+
+These surface typos in ``list_fields`` / ``detail_fields`` as ``manage.py check``
+warnings instead of letting them blow up with an ``AttributeError`` in front of
+the user at request time.
+"""
+
+# Django
+from django.contrib.admin.utils import flatten
+from django.core.checks import Warning, register
+
+
+def _detail_field_names(detail_fields):
+    if isinstance(detail_fields, dict):
+        names = []
+        for fieldset in detail_fields.values():
+            names += flatten(fieldset)
+        return names
+    return flatten(detail_fields or ())
+
+
+@register()
+def check_model_sites(app_configs, **kwargs):
+    from .services import FieldService
+    from .sites import site
+
+    errors = []
+    for model, model_site in site._registry.items():
+        fields = list(getattr(model_site, "list_fields", ()) or ())
+        fields += _detail_field_names(getattr(model_site, "detail_fields", ()))
+        for field in fields:
+            if not isinstance(field, str):
+                continue
+            try:
+                FieldService.get_field_label(model, field)
+            except AttributeError as error:
+                errors.append(
+                    Warning(
+                        "Invalid field %r in %s for model %s: %s"
+                        % (field, model_site.__class__.__name__, model.__name__, error),
+                        hint="Check the list_fields / detail_fields of the ModelSite.",
+                        id="superadmin.W001",
+                    )
+                )
+    return errors

superadmin/context_processors.py

@@ -0,0 +1,53 @@
+# Django
+from django.core.cache import cache
+
+# Models
+from .models import Menu
+from . import settings as superadmin_settings
+from .utils import get_menu_version, get_user_menu
+
+
+def menu(request):
+    return {"menu_tree": get_cached_user_menu(request.user)}
+
+
+def get_cached_user_menu(user):
+    if not user.is_authenticated or not user.is_active:
+        return []
+    key = "superadmin:menu:%s:%s" % (get_menu_version(), user.pk)
+    menu_tree = cache.get(key)
+    if menu_tree is None:
+        menu_tree = build_user_menu(user)
+        cache.set(key, menu_tree, superadmin_settings.MENU_CACHE_TIMEOUT)
+    return menu_tree
+
+
+def build_user_menu(user):
+    if not user.is_authenticated or not user.is_active:
+        return []
+
+    user_perms = set(user.get_all_permissions())
+    object_list = (
+        Menu.objects.filter(parent__isnull=True, is_active=True)
+        .select_related("action", "parent")
+        .prefetch_related(
+            "submenus",
+            "submenus__action",
+            "submenus__parent",
+            "submenus__submenus",
+            "submenus__submenus__action",
+            "submenus__submenus__parent",
+            "submenus__submenus__submenus",
+            "submenus__submenus__submenus__action",
+            "submenus__submenus__submenus__parent",
+            "submenus__submenus__submenus__submenus",
+            "submenus__submenus__submenus__submenus__action",
+            "submenus__submenus__submenus__submenus__parent",
+            "submenus__submenus__submenus__submenus__submenus",
+            "submenus__submenus__submenus__submenus__submenus__action",
+            "submenus__submenus__submenus__submenus__submenus__parent",
+        )
+    )
+    return get_user_menu(object_list, user, user_perms)
+
+

superadmin/decorators.py

@@ -0,0 +1,33 @@
+from django.apps import apps
+from django.core.exceptions import ImproperlyConfigured
+
+
+def register(model):
+    """
+    Register the given model(s) classes and wrapped ModelSite class:
+    @register(Author)
+    class AuthorSite(superadmin.ModelSite):
+        pass
+    """
+    from superadmin import ModelSite, site
+
+    def _model_site_wrapper(site_class):
+        if not model:
+            raise ValueError("One model must be passed to register.")
+
+        model_class = None
+        if isinstance(model, str):
+            try:
+                app_name, model_name = model.split(".")
+                model_class = apps.get_model(app_name, model_name)
+            except ValueError:
+                raise ImproperlyConfigured("Does not exist '%s' model" % model)
+
+        if not issubclass(site_class, ModelSite):
+            raise ValueError("Wrapped class must subclass ModelSite.")
+
+        site.register(model_class if model_class else model, site_class=site_class)
+
+        return site_class
+
+    return _model_site_wrapper

superadmin/forms.py

@@ -0,0 +1,66 @@
+# Python
+from functools import reduce
+
+# Django
+from django.forms import BaseModelForm
+from django.forms.models import ModelFormMetaclass as DjangoModelFormMetaclass
+from django.contrib.admin.utils import flatten
+from django.core.exceptions import ImproperlyConfigured
+
+
+class ModelFormMetaclass(DjangoModelFormMetaclass):
+    def __new__(mcs, name, bases, attrs):
+        fieldsets = None
+        if "Meta" in attrs and hasattr(attrs["Meta"], "fieldsets"):
+            fieldsets = attrs["Meta"].fieldsets
+            fields = mcs.__fields__(fieldsets)
+            if hasattr(attrs["Meta"], "fields"):
+                fields = fields + attrs["Meta"].fields
+            attrs["Meta"].fields = fields
+        new_class = super().__new__(mcs, name, bases, attrs)
+        if fieldsets:
+            new_class._meta.fieldsets = fieldsets
+        return new_class
+
+    def __fields__(fieldsets):
+        if isinstance(fieldsets, (list, tuple)):
+            fields = flatten(fieldsets)
+        elif isinstance(fieldsets, dict):
+            fields = reduce(
+                lambda acc, fieldset: acc + flatten(fieldset), fieldsets.values(), []
+            )
+        else:
+            raise ImproperlyConfigured(
+                "The fieldsets must be an instance of list, tuple or dict"
+            )
+        return tuple(fields)
+
+
+class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass):
+    def parse(self, fieldset):
+        def wrap(fields):
+            fields = fields if isinstance(fields, (list, tuple)) else [fields]
+            return {
+                "bs_cols": int(12 / len(fields)),
+                "fields": [self[field] for field in fields],
+            }
+
+        fieldset_list = list(map(wrap, fieldset))
+        return fieldset_list
+
+    def get_fieldsets(self):
+        fieldsets_list = self._meta.fieldsets
+        fieldsets = (
+            [(None, fieldsets_list)]
+            if isinstance(fieldsets_list, (list, tuple))
+            else fieldsets_list.items()
+        )
+        fieldsets = [
+            {"title": title or "", "fieldset": self.parse(fieldset)}
+            for title, fieldset in fieldsets
+        ]
+
+        return fieldsets
+
+    def has_fieldsets(self):
+        return hasattr(self._meta, "fieldsets")

superadmin/management/commands/base.py

@@ -0,0 +1,148 @@
+# Python
+import inspect
+from importlib import import_module
+
+# Django
+from django.db.models import Q
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.views.generic import View
+from django.apps import apps
+
+# Models
+from ...models import Action, Menu
+
+
+def get_views_catalog():
+    module_name = "django.views"
+
+    def map_module(module_name):
+        try:
+            module = import_module(module_name)
+        except ModuleNotFoundError:
+            return []
+
+        names = [
+            name
+            for name, cand in inspect.getmembers(module, inspect.isclass)
+            if issubclass(cand, View)
+        ]
+        for name, mod in inspect.getmembers(module, inspect.ismodule):
+            names.extend(map_module(f"{module_name}.{name}"))
+
+        return names
+
+    names = set(map_module(module_name))
+    return list(names)
+
+
+def get_actions_and_elements(app_config, VIEWS_CATALOG):
+    actions = {
+        action.element: action
+        for action in Action.objects.filter(app_label=app_config.label)
+    }
+
+    model_elements = {
+        model._meta.model_name: (
+            f"{app_config.verbose_name.capitalize()} | {model._meta.verbose_name.capitalize()}"
+        )
+        for model in app_config.get_models()
+    }
+
+    try:
+        module = import_module(f"{app_config.name}.views")
+        view_elements = {
+            name: (f"{app_config.verbose_name.capitalize()} | {name}")
+            for name, candidate in inspect.getmembers(module, inspect.isclass)
+            if issubclass(candidate, View) and not candidate.__name__ in VIEWS_CATALOG
+        }
+    except (ModuleNotFoundError, ImportError):
+        view_elements = {}
+
+    elements = {**model_elements, **view_elements}
+
+    return actions, elements, model_elements, view_elements
+
+
+def create_actions():
+    VIEWS_CATALOG = get_views_catalog()
+
+    for app in apps.get_app_configs():
+        actions, elements, m, v = get_actions_and_elements(app, VIEWS_CATALOG)
+
+        if not elements:
+            continue
+
+        acts = []
+        acts += [
+            Action(
+                to=Action.ToChoices.MODEL,
+                app_label=app.label,
+                name=name,
+                element=element,
+            )
+            for (element, name) in m.items()
+            if element not in actions
+        ]
+        acts += [
+            Action(
+                to=Action.ToChoices.CLASSVIEW,
+                app_label=app.label,
+                name=name,
+                element=element,
+            )
+            for (element, name) in v.items()
+            if element not in actions
+        ]
+
+        Action.objects.bulk_create(acts)
+
+
+def build_menu(data):
+    create_actions()
+    Menu.objects.all().delete()
+    default_action = Action.objects.get(app_label="superadmin", element="ModuleView")
+
+    def permissions(data, action):
+        content_type = ContentType.objects.get_for_model(Permission)
+        action.permissions.clear()
+        for perm in data:
+            obj, created = Permission.objects.update_or_create(
+                codename=perm.get("codename"),
+                content_type=content_type,
+                defaults={"name": perm.get("name")},
+            )
+            action.permissions.add(obj)
+
+    RESERVED_KEYS = {"app", "model", "view", "permissions", "icon"}
+
+    def build(name, data, action, parent=None, menu_list=[]):
+        default = action
+        is_group = True
+        icon = data.get("icon") if isinstance(data, dict) else None
+        if "app" in data:
+            element = data["model"] if "model" in data else data["view"]
+            default = Action.objects.get(app_label=data["app"], element=element)
+            is_group = False
+            if "permissions" in data:
+                permissions(data["permissions"], default)
+
+        current = Menu.objects.create(
+            parent=parent,
+            name=name.capitalize(),
+            action=default,
+            is_group=is_group,
+            sequence=len(menu_list) + 1,
+            icon_class=icon,
+        )
+        menu_list.append(current)
+        if is_group:
+            for key in data:
+                if key in RESERVED_KEYS:
+                    continue
+                build(key, data[key], action, parent=current, menu_list=menu_list)
+        return menu_list
+
+    menus = []
+    for key in data:
+        build(key, data[key], default_action, menu_list=menus)

superadmin/management/commands/createactions.py

@@ -0,0 +1,13 @@
+# Django
+from django.core.management.base import BaseCommand, CommandError
+
+# local
+from .base import create_actions
+
+
+class Command(BaseCommand):
+    help = "Create actions mapping all apps"
+
+    def handle(self, *args, **options):
+        create_actions()
+        self.stdout.write(self.style.SUCCESS("Successfully actions was created"))

superadmin/management/commands/createbasemenu.py

@@ -0,0 +1,57 @@
+# Django
+from django.core.management.base import BaseCommand, CommandError
+from django.core.management import call_command
+
+# Models
+from superadmin.models import Action, Menu
+
+#
+from superadmin import site
+
+
+class Command(BaseCommand):
+    help = "Create base menu mapping all apps"
+
+    def handle(self, *args, **options):
+        call_command("createactions")
+
+        Menu.objects.all().delete()
+
+        default_action = Action.objects.get(
+            app_label="superadmin", element="ModuleView"
+        )
+
+        apps = {}
+        for model in site._registry:
+            if model._meta.app_config in apps:
+                apps[model._meta.app_config].append(model)
+            else:
+                apps[model._meta.app_config] = [model]
+
+        sequence = 1
+        for app in apps:
+            menu = Menu.objects.create(
+                name=app.verbose_name.capitalize(),
+                action=default_action,
+                is_group=True,
+                sequence=sequence,
+            )
+            sequence += 1
+
+            index = 1
+            for model in apps[app]:
+                action = Action.objects.get(
+                    app_label=app.label, element=model._meta.model_name
+                )
+
+                Menu.objects.create(
+                    parent=menu,
+                    name=model._meta.verbose_name_plural.capitalize(),
+                    action=action,
+                    is_group=False,
+                    sequence=index,
+                )
+
+                index += 1
+
+        self.stdout.write(self.style.SUCCESS("Successfully base menu was created"))