mirror of https://gitlab.federez.net/re2o/re2o
guimoz
8 years ago
29 changed files with 1232 additions and 841 deletions
@ -0,0 +1,86 @@ |
|||
# ⁻*- mode: python; coding: utf-8 -*- |
|||
# Re2o est un logiciel d'administration développé initiallement au rezometz. Il |
|||
# se veut agnostique au réseau considéré, de manière à être installable en |
|||
# quelques clics. |
|||
# |
|||
# Copyright © 2018 Lev-Arcady Sellem |
|||
# |
|||
# This program is free software; you can redistribute it and/or modify |
|||
# it under the terms of the GNU General Public License as published by |
|||
# the Free Software Foundation; either version 2 of the License, or |
|||
# (at your option) any later version. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU General Public License for more details. |
|||
# |
|||
# You should have received a copy of the GNU General Public License along |
|||
# with this program; if not, write to the Free Software Foundation, Inc., |
|||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
|||
|
|||
import os, sys, pwd |
|||
|
|||
proj_path="/var/www/re2o" |
|||
os.environ.setdefault("DJANGO_SETTINGS_MODULE","re2o.settings") |
|||
sys.path.append(proj_path) |
|||
os.chdir(proj_path) |
|||
from django.core.wsgi import get_wsgi_application |
|||
application = get_wsgi_application() |
|||
|
|||
|
|||
from django.core.management.base import CommandError |
|||
from users.models import User |
|||
|
|||
from django.utils.html import strip_tags |
|||
from reversion import revisions as reversion |
|||
from django.db import transaction |
|||
from getpass import getpass |
|||
|
|||
|
|||
def get_user(pseudo): |
|||
"""Cherche un utilisateur re2o à partir de son pseudo""" |
|||
user = User.objects.filter(pseudo=pseudo) |
|||
if len(user)==0: |
|||
raise CommandError("Utilisateur invalide") |
|||
if len(user)>1: |
|||
raise CommandError("Plusieurs utilisateurs correspondant à ce pseudo. Ceci NE DEVRAIT PAS arriver") |
|||
return user[0] |
|||
|
|||
|
|||
def get_system_user(): |
|||
"""Retourne l'utilisateur système ayant lancé la commande""" |
|||
return pwd.getpwuid(int(os.getenv("SUDO_UID") or os.getuid())).pw_name |
|||
|
|||
|
|||
def form_cli(Form,user,action,*args,**kwargs): |
|||
""" |
|||
Remplit un formulaire à partir de la ligne de commande |
|||
Form : le formulaire (sous forme de classe) à remplir |
|||
user : l'utilisateur re2o faisant la modification |
|||
action : l'action réalisée par le formulaire (pour les logs) |
|||
Les arguments suivants sont transmis tels quels au formulaire. |
|||
""" |
|||
data={} |
|||
dumb_form = Form(user=user,*args,**kwargs) |
|||
for key in dumb_form.fields: |
|||
if not dumb_form.fields[key].widget.input_type=='hidden': |
|||
if dumb_form.fields[key].widget.input_type=='password': |
|||
data[key]=getpass("%s : " % dumb_form.fields[key].label) |
|||
else: |
|||
data[key]=input("%s : " % dumb_form.fields[key].label) |
|||
|
|||
form = Form(data,user=user,*args,**kwargs) |
|||
if not form.is_valid(): |
|||
sys.stderr.write("Erreurs : \n") |
|||
for err in form.errors: |
|||
#Oui, oui, on gère du HTML là où d'autres ont eu la lumineuse idée de le mettre |
|||
sys.stderr.write("\t%s : %s\n" % (err,strip_tags(form.errors[err]))) |
|||
raise CommandError("Formulaire invalide") |
|||
|
|||
with transaction.atomic(), reversion.create_revision(): |
|||
form.save() |
|||
reversion.set_user(user) |
|||
reversion.set_comment(action) |
|||
|
|||
sys.stdout.write("%s : effectué. La modification peut prendre quelques minutes pour s'appliquer.\n" % action) |
|||
@ -0,0 +1,228 @@ |
|||
# -*- coding: utf-8 -*- |
|||
import sys |
|||
import json |
|||
|
|||
import six |
|||
from django.conf import settings |
|||
from django.core.management.base import BaseCommand, CommandError |
|||
|
|||
from topologie.management.modelviz import ModelGraph, generate_dot |
|||
from django_extensions.management.utils import signalcommand |
|||
|
|||
try: |
|||
import pygraphviz |
|||
HAS_PYGRAPHVIZ = True |
|||
except ImportError: |
|||
HAS_PYGRAPHVIZ = False |
|||
|
|||
try: |
|||
try: |
|||
import pydotplus as pydot |
|||
except ImportError: |
|||
import pydot |
|||
HAS_PYDOT = True |
|||
except ImportError: |
|||
HAS_PYDOT = False |
|||
|
|||
|
|||
class Command(BaseCommand): |
|||
help = "Creates a GraphViz dot file for the specified app names. You can pass multiple app names and they will all be combined into a single model. Output is usually directed to a dot file." |
|||
|
|||
can_import_settings = True |
|||
|
|||
def __init__(self, *args, **kwargs): |
|||
"""Allow defaults for arguments to be set in settings.GRAPH_MODELS. |
|||
Each argument in self.arguments is a dict where the key is the |
|||
space-separated args and the value is our kwarg dict. |
|||
The default from settings is keyed as the long arg name with '--' |
|||
removed and any '-' replaced by '_'. |
|||
""" |
|||
self.arguments = { |
|||
'--pygraphviz': { |
|||
'action': 'store_true', 'dest': 'pygraphviz', |
|||
'help': 'Use PyGraphViz to generate the image.'}, |
|||
|
|||
'--pydot': {'action': 'store_true', 'dest': 'pydot', |
|||
'help': 'Use PyDot(Plus) to generate the image.'}, |
|||
|
|||
'--disable-fields -d': { |
|||
'action': 'store_true', 'dest': 'disable_fields', |
|||
'help': 'Do not show the class member fields'}, |
|||
|
|||
'--group-models -g': { |
|||
'action': 'store_true', 'dest': 'group_models', |
|||
'help': 'Group models together respective to their ' |
|||
'application'}, |
|||
|
|||
'--all-applications -a': { |
|||
'action': 'store_true', 'dest': 'all_applications', |
|||
'help': 'Automatically include all applications from ' |
|||
'INSTALLED_APPS'}, |
|||
|
|||
'--output -o': { |
|||
'action': 'store', 'dest': 'outputfile', |
|||
'help': 'Render output file. Type of output dependend on file ' |
|||
'extensions. Use png or jpg to render graph to image.'}, |
|||
|
|||
'--layout -l': { |
|||
'action': 'store', 'dest': 'layout', 'default': 'dot', |
|||
'help': 'Layout to be used by GraphViz for visualization. ' |
|||
'Layouts: circo dot fdp neato nop nop1 nop2 twopi'}, |
|||
|
|||
'--verbose-names -n': { |
|||
'action': 'store_true', 'dest': 'verbose_names', |
|||
'help': 'Use verbose_name of models and fields'}, |
|||
|
|||
'--language -L': { |
|||
'action': 'store', 'dest': 'language', |
|||
'help': 'Specify language used for verbose_name localization'}, |
|||
|
|||
'--exclude-columns -x': { |
|||
'action': 'store', 'dest': 'exclude_columns', |
|||
'help': 'Exclude specific column(s) from the graph. ' |
|||
'Can also load exclude list from file.'}, |
|||
|
|||
'--exclude-models -X': { |
|||
'action': 'store', 'dest': 'exclude_models', |
|||
'help': 'Exclude specific model(s) from the graph. Can also ' |
|||
'load exclude list from file. Wildcards (*) are allowed.'}, |
|||
|
|||
'--include-models -I': { |
|||
'action': 'store', 'dest': 'include_models', |
|||
'help': 'Restrict the graph to specified models. Wildcards ' |
|||
'(*) are allowed.'}, |
|||
|
|||
'--inheritance -e': { |
|||
'action': 'store_true', 'dest': 'inheritance', 'default': True, |
|||
'help': 'Include inheritance arrows (default)'}, |
|||
|
|||
'--no-inheritance -E': { |
|||
'action': 'store_false', 'dest': 'inheritance', |
|||
'help': 'Do not include inheritance arrows'}, |
|||
|
|||
'--hide-relations-from-fields -R': { |
|||
'action': 'store_false', 'dest': 'relations_as_fields', |
|||
'default': True, |
|||
'help': 'Do not show relations as fields in the graph.'}, |
|||
|
|||
'--disable-sort-fields -S': { |
|||
'action': 'store_false', 'dest': 'sort_fields', |
|||
'default': True, 'help': 'Do not sort fields'}, |
|||
|
|||
'--json': {'action': 'store_true', 'dest': 'json', |
|||
'help': 'Output graph data as JSON'} |
|||
} |
|||
|
|||
defaults = getattr(settings, 'GRAPH_MODELS', None) |
|||
|
|||
if defaults: |
|||
for argument in self.arguments: |
|||
arg_split = argument.split(' ') |
|||
setting_opt = arg_split[0].lstrip('-').replace('-', '_') |
|||
if setting_opt in defaults: |
|||
self.arguments[argument]['default'] = defaults[setting_opt] |
|||
|
|||
super(Command, self).__init__(*args, **kwargs) |
|||
|
|||
def add_arguments(self, parser): |
|||
"""Unpack self.arguments for parser.add_arguments.""" |
|||
parser.add_argument('app_label', nargs='*') |
|||
for argument in self.arguments: |
|||
parser.add_argument(*argument.split(' '), |
|||
**self.arguments[argument]) |
|||
|
|||
@signalcommand |
|||
def handle(self, *args, **options): |
|||
args = options['app_label'] |
|||
if len(args) < 1 and not options['all_applications']: |
|||
raise CommandError("need one or more arguments for appname") |
|||
|
|||
use_pygraphviz = options.get('pygraphviz', False) |
|||
use_pydot = options.get('pydot', False) |
|||
use_json = options.get('json', False) |
|||
if use_json and (use_pydot or use_pygraphviz): |
|||
raise CommandError("Cannot specify --json with --pydot or --pygraphviz") |
|||
|
|||
cli_options = ' '.join(sys.argv[2:]) |
|||
graph_models = ModelGraph(args, cli_options=cli_options, **options) |
|||
graph_models.generate_graph_data() |
|||
graph_data = graph_models.get_graph_data(as_json=use_json) |
|||
if use_json: |
|||
self.render_output_json(graph_data, **options) |
|||
return |
|||
|
|||
dotdata = generate_dot(graph_data) |
|||
if not six.PY3: |
|||
dotdata = dotdata.encode('utf-8') |
|||
if options['outputfile']: |
|||
if not use_pygraphviz and not use_pydot: |
|||
if HAS_PYGRAPHVIZ: |
|||
use_pygraphviz = True |
|||
elif HAS_PYDOT: |
|||
use_pydot = True |
|||
if use_pygraphviz: |
|||
self.render_output_pygraphviz(dotdata, **options) |
|||
elif use_pydot: |
|||
self.render_output_pydot(dotdata, **options) |
|||
else: |
|||
raise CommandError("Neither pygraphviz nor pydotplus could be found to generate the image") |
|||
else: |
|||
self.print_output(dotdata) |
|||
|
|||
def print_output(self, dotdata): |
|||
if six.PY3 and isinstance(dotdata, six.binary_type): |
|||
dotdata = dotdata.decode() |
|||
|
|||
print(dotdata) |
|||
|
|||
def render_output_json(self, graph_data, **kwargs): |
|||
output_file = kwargs.get('outputfile') |
|||
if output_file: |
|||
with open(output_file, 'wt') as json_output_f: |
|||
json.dump(graph_data, json_output_f) |
|||
else: |
|||
print(json.dumps(graph_data)) |
|||
|
|||
def render_output_pygraphviz(self, dotdata, **kwargs): |
|||
"""Renders the image using pygraphviz""" |
|||
if not HAS_PYGRAPHVIZ: |
|||
raise CommandError("You need to install pygraphviz python module") |
|||
|
|||
version = pygraphviz.__version__.rstrip("-svn") |
|||
try: |
|||
if tuple(int(v) for v in version.split('.')) < (0, 36): |
|||
# HACK around old/broken AGraph before version 0.36 (ubuntu ships with this old version) |
|||
import tempfile |
|||
tmpfile = tempfile.NamedTemporaryFile() |
|||
tmpfile.write(dotdata) |
|||
tmpfile.seek(0) |
|||
dotdata = tmpfile.name |
|||
except ValueError: |
|||
pass |
|||
|
|||
graph = pygraphviz.AGraph(dotdata) |
|||
graph.layout(prog=kwargs['layout']) |
|||
graph.draw(kwargs['outputfile']) |
|||
|
|||
def render_output_pydot(self, dotdata, **kwargs): |
|||
"""Renders the image using pydot""" |
|||
if not HAS_PYDOT: |
|||
raise CommandError("You need to install pydot python module") |
|||
|
|||
graph = pydot.graph_from_dot_data(dotdata) |
|||
if not graph: |
|||
raise CommandError("pydot returned an error") |
|||
if isinstance(graph, (list, tuple)): |
|||
if len(graph) > 1: |
|||
sys.stderr.write("Found more then one graph, rendering only the first one.\n") |
|||
graph = graph[0] |
|||
|
|||
output_file = kwargs['outputfile'] |
|||
formats = ['bmp', 'canon', 'cmap', 'cmapx', 'cmapx_np', 'dot', 'dia', 'emf', |
|||
'em', 'fplus', 'eps', 'fig', 'gd', 'gd2', 'gif', 'gv', 'imap', |
|||
'imap_np', 'ismap', 'jpe', 'jpeg', 'jpg', 'metafile', 'pdf', |
|||
'pic', 'plain', 'plain-ext', 'png', 'pov', 'ps', 'ps2', 'svg', |
|||
'svgz', 'tif', 'tiff', 'tk', 'vml', 'vmlz', 'vrml', 'wbmp', 'xdot'] |
|||
ext = output_file[output_file.rfind('.') + 1:] |
|||
format = ext if ext in formats else 'raw' |
|||
graph.write(output_file, format=format) |
|||
@ -0,0 +1,405 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
modelviz.py - DOT file generator for Django Models |
|||
Based on: |
|||
Django model to DOT (Graphviz) converter |
|||
by Antonio Cavedoni <antonio@cavedoni.org> |
|||
Adapted to be used with django-extensions |
|||
""" |
|||
|
|||
import datetime |
|||
import os |
|||
import re |
|||
|
|||
import six |
|||
from django.apps import apps |
|||
from django.db.models.fields.related import ( |
|||
ForeignKey, ManyToManyField, OneToOneField, RelatedField, |
|||
) |
|||
from django.contrib.contenttypes.fields import GenericRelation |
|||
from django.template import Context, Template, loader |
|||
from django.utils.encoding import force_bytes, force_str |
|||
from django.utils.safestring import mark_safe |
|||
from django.utils.translation import activate as activate_language |
|||
|
|||
|
|||
__version__ = "1.1" |
|||
__license__ = "Python" |
|||
__author__ = "Bas van Oostveen <v.oostveen@gmail.com>", |
|||
__contributors__ = [ |
|||
"Antonio Cavedoni <http://cavedoni.com/>" |
|||
"Stefano J. Attardi <http://attardi.org/>", |
|||
"limodou <http://www.donews.net/limodou/>", |
|||
"Carlo C8E Miron", |
|||
"Andre Campos <cahenan@gmail.com>", |
|||
"Justin Findlay <jfindlay@gmail.com>", |
|||
"Alexander Houben <alexander@houben.ch>", |
|||
"Joern Hees <gitdev@joernhees.de>", |
|||
"Kevin Cherepski <cherepski@gmail.com>", |
|||
"Jose Tomas Tocino <theom3ga@gmail.com>", |
|||
"Adam Dobrawy <naczelnik@jawnosc.tk>", |
|||
"Mikkel Munch Mortensen <https://www.detfalskested.dk/>", |
|||
"Andrzej Bistram <andrzej.bistram@gmail.com>", |
|||
] |
|||
|
|||
|
|||
def parse_file_or_list(arg): |
|||
if not arg: |
|||
return [] |
|||
if isinstance(arg, (list, tuple, set)): |
|||
return arg |
|||
if ',' not in arg and os.path.isfile(arg): |
|||
return [e.strip() for e in open(arg).readlines()] |
|||
return [e.strip() for e in arg.split(',')] |
|||
|
|||
|
|||
class ModelGraph(object): |
|||
def __init__(self, app_labels, **kwargs): |
|||
self.graphs = [] |
|||
self.cli_options = kwargs.get('cli_options', None) |
|||
self.disable_fields = kwargs.get('disable_fields', False) |
|||
self.include_models = parse_file_or_list( |
|||
kwargs.get('include_models', "") |
|||
) |
|||
self.all_applications = kwargs.get('all_applications', False) |
|||
self.use_subgraph = kwargs.get('group_models', False) |
|||
self.verbose_names = kwargs.get('verbose_names', False) |
|||
self.inheritance = kwargs.get('inheritance', True) |
|||
self.relations_as_fields = kwargs.get("relations_as_fields", True) |
|||
self.sort_fields = kwargs.get("sort_fields", True) |
|||
self.language = kwargs.get('language', None) |
|||
if self.language is not None: |
|||
activate_language(self.language) |
|||
self.exclude_columns = parse_file_or_list( |
|||
kwargs.get('exclude_columns', "") |
|||
) |
|||
self.exclude_models = parse_file_or_list( |
|||
kwargs.get('exclude_models', "") |
|||
) |
|||
if self.all_applications: |
|||
self.app_labels = [app.label for app in apps.get_app_configs()] |
|||
else: |
|||
self.app_labels = app_labels |
|||
|
|||
def generate_graph_data(self): |
|||
self.process_apps() |
|||
|
|||
nodes = [] |
|||
for graph in self.graphs: |
|||
nodes.extend([e['name'] for e in graph['models']]) |
|||
|
|||
for graph in self.graphs: |
|||
for model in graph['models']: |
|||
for relation in model['relations']: |
|||
if relation is not None: |
|||
if relation['target'] in nodes: |
|||
relation['needs_node'] = False |
|||
|
|||
def get_graph_data(self, as_json=False): |
|||
now = datetime.datetime.now() |
|||
graph_data = { |
|||
'created_at': now.strftime("%Y-%m-%d %H:%M"), |
|||
'cli_options': self.cli_options, |
|||
'disable_fields': self.disable_fields, |
|||
'use_subgraph': self.use_subgraph, |
|||
} |
|||
|
|||
if as_json: |
|||
graph_data['graphs'] = [context.flatten() for context in self.graphs] |
|||
else: |
|||
graph_data['graphs'] = self.graphs |
|||
|
|||
return graph_data |
|||
|
|||
def add_attributes(self, field, abstract_fields): |
|||
if self.verbose_names and field.verbose_name: |
|||
label = force_bytes(field.verbose_name) |
|||
if label.islower(): |
|||
label = label.capitalize() |
|||
else: |
|||
label = field.name |
|||
|
|||
t = type(field).__name__ |
|||
if isinstance(field, (OneToOneField, ForeignKey)): |
|||
remote_field = field.remote_field if hasattr(field, 'remote_field') else field.rel # Remove me after Django 1.8 is unsupported |
|||
t += " ({0})".format(remote_field.field_name) |
|||
# TODO: ManyToManyField, GenericRelation |
|||
|
|||
return { |
|||
'name': field.name, |
|||
'label': label, |
|||
'type': t, |
|||
'blank': field.blank, |
|||
'abstract': field in abstract_fields, |
|||
'relation': isinstance(field, RelatedField), |
|||
'primary_key': field.primary_key, |
|||
} |
|||
|
|||
def add_relation(self, field, model, extras=""): |
|||
if self.verbose_names and field.verbose_name: |
|||
label = force_bytes(field.verbose_name) |
|||
if label.islower(): |
|||
label = label.capitalize() |
|||
else: |
|||
label = field.name |
|||
|
|||
# show related field name |
|||
if hasattr(field, 'related_query_name'): |
|||
related_query_name = field.related_query_name() |
|||
if self.verbose_names and related_query_name.islower(): |
|||
related_query_name = related_query_name.replace('_', ' ').capitalize() |
|||
label = '{} ({})'.format(label, force_str(related_query_name)) |
|||
|
|||
# handle self-relationships and lazy-relationships |
|||
remote_field = field.remote_field if hasattr(field, 'remote_field') else field.rel # Remove me after Django 1.8 is unsupported |
|||
remote_field_model = remote_field.model if hasattr(remote_field, 'model') else remote_field.to # Remove me after Django 1.8 is unsupported |
|||
if isinstance(remote_field_model, six.string_types): |
|||
if remote_field_model == 'self': |
|||
target_model = field.model |
|||
else: |
|||
if '.' in remote_field_model: |
|||
app_label, model_name = remote_field_model.split('.', 1) |
|||
else: |
|||
app_label = field.model._meta.app_label |
|||
model_name = remote_field_model |
|||
target_model = apps.get_model(app_label, model_name) |
|||
else: |
|||
target_model = remote_field_model |
|||
|
|||
_rel = self.get_relation_context(target_model, field, label, extras) |
|||
|
|||
if _rel not in model['relations'] and self.use_model(_rel['target']): |
|||
return _rel |
|||
|
|||
def get_abstract_models(self, appmodels): |
|||
abstract_models = [] |
|||
for appmodel in appmodels: |
|||
abstract_models += [abstract_model for abstract_model in |
|||
appmodel.__bases__ if |
|||
hasattr(abstract_model, '_meta') and |
|||
abstract_model._meta.abstract] |
|||
abstract_models = list(set(abstract_models)) # remove duplicates |
|||
return abstract_models |
|||
|
|||
def get_app_context(self, app): |
|||
return Context({ |
|||
'name': '"%s"' % app.name, |
|||
'app_name': "%s" % app.name, |
|||
'cluster_app_name': "cluster_%s" % app.name.replace(".", "_"), |
|||
'models': [] |
|||
}) |
|||
|
|||
def get_appmodel_attributes(self, appmodel): |
|||
if self.relations_as_fields: |
|||
attributes = [field for field in appmodel._meta.local_fields] |
|||
else: |
|||
# Find all the 'real' attributes. Relations are depicted as graph edges instead of attributes |
|||
attributes = [field for field in appmodel._meta.local_fields if not |
|||
isinstance(field, RelatedField)] |
|||
return attributes |
|||
|
|||
def get_appmodel_abstracts(self, appmodel): |
|||
return [abstract_model.__name__ for abstract_model in |
|||
appmodel.__bases__ if |
|||
hasattr(abstract_model, '_meta') and |
|||
abstract_model._meta.abstract] |
|||
|
|||
def get_appmodel_context(self, appmodel, appmodel_abstracts): |
|||
context = { |
|||
'app_name': appmodel.__module__.replace(".", "_"), |
|||
'name': appmodel.__name__, |
|||
'abstracts': appmodel_abstracts, |
|||
'fields': [], |
|||
'relations': [] |
|||
} |
|||
|
|||
if self.verbose_names and appmodel._meta.verbose_name: |
|||
context['label'] = force_bytes(appmodel._meta.verbose_name) |
|||
else: |
|||
context['label'] = context['name'] |
|||
|
|||
return context |
|||
|
|||
def get_bases_abstract_fields(self, c): |
|||
_abstract_fields = [] |
|||
for e in c.__bases__: |
|||
if hasattr(e, '_meta') and e._meta.abstract: |
|||
_abstract_fields.extend(e._meta.fields) |
|||
_abstract_fields.extend(self.get_bases_abstract_fields(e)) |
|||
return _abstract_fields |
|||
|
|||
def get_inheritance_context(self, appmodel, parent): |
|||
label = "multi-table" |
|||
if parent._meta.abstract: |
|||
label = "abstract" |
|||
if appmodel._meta.proxy: |
|||
label = "proxy" |
|||
label += r"\ninheritance" |
|||
return { |
|||
'target_app': parent.__module__.replace(".", "_"), |
|||
'target': parent.__name__, |
|||
'type': "inheritance", |
|||
'name': "inheritance", |
|||
'label': label, |
|||
'arrows': '[arrowhead=empty, arrowtail=none, dir=both]', |
|||
'needs_node': True, |
|||
} |
|||
|
|||
def get_models(self, app): |
|||
appmodels = list(app.get_models()) |
|||
return appmodels |
|||
|
|||
def get_relation_context(self, target_model, field, label, extras): |
|||
return { |
|||
'target_app': target_model.__module__.replace('.', '_'), |
|||
'target': target_model.__name__, |
|||
'type': type(field).__name__, |
|||
'name': field.name, |
|||
'label': label, |
|||
'arrows': extras, |
|||
'needs_node': True |
|||
} |
|||
|
|||
def process_attributes(self, field, model, pk, abstract_fields): |
|||
newmodel = model.copy() |
|||
if self.skip_field(field) or pk and field == pk: |
|||
return newmodel |
|||
newmodel['fields'].append(self.add_attributes(field, abstract_fields)) |
|||
return newmodel |
|||
|
|||
def process_apps(self): |
|||
for app_label in self.app_labels: |
|||
app = apps.get_app_config(app_label) |
|||
if not app: |
|||
continue |
|||
app_graph = self.get_app_context(app) |
|||
app_models = self.get_models(app) |
|||
abstract_models = self.get_abstract_models(app_models) |
|||
app_models = abstract_models + app_models |
|||
|
|||
for appmodel in app_models: |
|||
if not self.use_model(appmodel._meta.object_name): |
|||
continue |
|||
appmodel_abstracts = self.get_appmodel_abstracts(appmodel) |
|||
abstract_fields = self.get_bases_abstract_fields(appmodel) |
|||
model = self.get_appmodel_context(appmodel, appmodel_abstracts) |
|||
attributes = self.get_appmodel_attributes(appmodel) |
|||
|
|||
# find primary key and print it first, ignoring implicit id if other pk exists |
|||
pk = appmodel._meta.pk |
|||
if pk and not appmodel._meta.abstract and pk in attributes: |
|||
model['fields'].append(self.add_attributes(pk, abstract_fields)) |
|||
|
|||
for field in attributes: |
|||
model = self.process_attributes(field, model, pk, abstract_fields) |
|||
|
|||
if self.sort_fields: |
|||
model = self.sort_model_fields(model) |
|||
|
|||
for field in appmodel._meta.local_fields: |
|||
model = self.process_local_fields(field, model, abstract_fields) |
|||
|
|||
for field in appmodel._meta.local_many_to_many: |
|||
model = self.process_local_many_to_many(field, model) |
|||
|
|||
if self.inheritance: |
|||
# add inheritance arrows |
|||
for parent in appmodel.__bases__: |
|||
model = self.process_parent(parent, appmodel, model) |
|||
|
|||
app_graph['models'].append(model) |
|||
if app_graph['models']: |
|||
self.graphs.append(app_graph) |
|||
|
|||
def process_local_fields(self, field, model, abstract_fields): |
|||
newmodel = model.copy() |
|||
if (field.attname.endswith('_ptr_id') or # excluding field redundant with inheritance relation |
|||
field in abstract_fields or # excluding fields inherited from abstract classes. they too show as local_fields |
|||
self.skip_field(field)): |
|||
return newmodel |
|||
if isinstance(field, OneToOneField): |
|||
newmodel['relations'].append(self.add_relation(field, newmodel, '[arrowhead=none, arrowtail=none, dir=both]')) |
|||
elif isinstance(field, ForeignKey): |
|||
newmodel['relations'].append(self.add_relation(field, newmodel, '[arrowhead=none, arrowtail=dot, dir=both]')) |
|||
return newmodel |
|||
|
|||
def process_local_many_to_many(self, field, model): |
|||
newmodel = model.copy() |
|||
if self.skip_field(field): |
|||
return newmodel |
|||
if isinstance(field, ManyToManyField): |
|||
remote_field = field.remote_field if hasattr(field, 'remote_field') else field.rel # Remove me after Django 1.8 is unsupported |
|||
if hasattr(remote_field.through, '_meta') and remote_field.through._meta.auto_created: |
|||
newmodel['relations'].append(self.add_relation(field, newmodel, '[arrowhead=dot arrowtail=dot, dir=both]')) |
|||
elif isinstance(field, GenericRelation): |
|||
newmodel['relations'].append(self.add_relation(field, newmodel, mark_safe('[style="dotted", arrowhead=normal, arrowtail=normal, dir=both]'))) |
|||
return newmodel |
|||
|
|||
def process_parent(self, parent, appmodel, model): |
|||
newmodel = model.copy() |
|||
if hasattr(parent, "_meta"): # parent is a model |
|||
_rel = self.get_inheritance_context(appmodel, parent) |
|||
# TODO: seems as if abstract models aren't part of models.getModels, which is why they are printed by this without any attributes. |
|||
if _rel not in newmodel['relations'] and self.use_model(_rel['target']): |
|||
newmodel['relations'].append(_rel) |
|||
return newmodel |
|||
|
|||
def sort_model_fields(self, model): |
|||
newmodel = model.copy() |
|||
newmodel['fields'] = sorted(newmodel['fields'], key=lambda field: (not field['primary_key'], not field['relation'], field['label'])) |
|||
return newmodel |
|||
|
|||
def use_model(self, model_name): |
|||
""" |
|||
Decide whether to use a model, based on the model name and the lists of |
|||
models to exclude and include. |
|||
""" |
|||
# Check against exclude list. |
|||
if self.exclude_models: |
|||
for model_pattern in self.exclude_models: |
|||
model_pattern = '^%s$' % model_pattern.replace('*', '.*') |
|||
if re.search(model_pattern, model_name): |
|||
return False |
|||
# Check against exclude list. |
|||
elif self.include_models: |
|||
for model_pattern in self.include_models: |
|||
model_pattern = '^%s$' % model_pattern.replace('*', '.*') |
|||
if re.search(model_pattern, model_name): |
|||
return True |
|||
# Return `True` if `include_models` is falsey, otherwise return `False`. |
|||
return not self.include_models |
|||
|
|||
def skip_field(self, field): |
|||
if self.exclude_columns: |
|||
if self.verbose_names and field.verbose_name: |
|||
if field.verbose_name in self.exclude_columns: |
|||
return True |
|||
if field.name in self.exclude_columns: |
|||
return True |
|||
return False |
|||
|
|||
|
|||
def generate_dot(graph_data, template='django_extensions/graph_models/digraph.dot'): |
|||
t = loader.get_template(template) |
|||
|
|||
if not isinstance(t, Template) and not (hasattr(t, 'template') and isinstance(t.template, Template)): |
|||
raise Exception("Default Django template loader isn't used. " |
|||
"This can lead to the incorrect template rendering. " |
|||
"Please, check the settings.") |
|||
|
|||
c = Context(graph_data).flatten() |
|||
dot = t.render(c) |
|||
|
|||
return dot |
|||
|
|||
|
|||
def generate_graph_data(*args, **kwargs): |
|||
generator = ModelGraph(*args, **kwargs) |
|||
generator.generate_graph_data() |
|||
return generator.get_graph_data() |
|||
|
|||
|
|||
def use_model(model, include_models, exclude_models): |
|||
generator = ModelGraph([], include_models=include_models, exclude_models=exclude_models) |
|||
return generator.use_model(model) |
|||
|
|||
@ -0,0 +1,47 @@ |
|||
# ⁻*- mode: python; coding: utf-8 -*- |
|||
# Re2o est un logiciel d'administration développé initiallement au rezometz. Il |
|||
# se veut agnostique au réseau considéré, de manière à être installable en |
|||
# quelques clics. |
|||
# |
|||
# Copyright © 2018 Lev-Arcady Sellem |
|||
# |
|||
# This program is free software; you can redistribute it and/or modify |
|||
# it under the terms of the GNU General Public License as published by |
|||
# the Free Software Foundation; either version 2 of the License, or |
|||
# (at your option) any later version. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU General Public License for more details. |
|||
# |
|||
# You should have received a copy of the GNU General Public License along |
|||
# with this program; if not, write to the Free Software Foundation, Inc., |
|||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
|||
|
|||
import os, pwd |
|||
|
|||
from django.core.management.base import BaseCommand, CommandError |
|||
from users.forms import PassForm |
|||
from re2o.script_utils import get_user, get_system_user, form_cli |
|||
|
|||
class Command(BaseCommand): |
|||
help = "Changer le mot de passe d'un utilisateur" |
|||
|
|||
def add_arguments(self, parser): |
|||
parser.add_argument('target_username', nargs='?') |
|||
|
|||
def handle(self, *args, **kwargs): |
|||
|
|||
current_username = get_system_user() |
|||
current_user = get_user(current_username) |
|||
target_username = kwargs["target_username"] or current_username |
|||
target_user = get_user(target_username) |
|||
|
|||
ok, msg = target_user.can_change_password(current_user) |
|||
if not ok: |
|||
raise CommandError(msg) |
|||
|
|||
self.stdout.write("Changement du mot de passe de %s" % target_user.pseudo) |
|||
|
|||
form_cli(PassForm,current_user,"Changement du mot de passe",instance=target_user) |
|||
Loading…
Reference in new issue