class Meta: model = rel.related_model fields = get_metadata(rel.related_model, 'form_fields', '__all__') exclude = get_metadata(rel.related_model, 'exclude_fields', ()) submit_label = related_obj.pk and u'Atualizar' or button_label title = form_title
def add(self, queryset, start_field, end_field=None, color='#ccc', action_names=[], as_initial_date=False): item = dict(queryset=dumps_qs_query(queryset), start_field=start_field, end_field=end_field, color=color, action_names=','.join(action_names)) self.items.append(item) if as_initial_date: qs_initial_date = queryset.order_by(start_field).values_list( start_field, flat=True) if qs_initial_date.exists(): self.set_initial_date(qs_initial_date[0]) if queryset.model not in self.models and has_add_permission( self.request, queryset.model): label = get_metadata(queryset.model, 'verbose_name') app_label = get_metadata(queryset.model, 'app_label') model_name = queryset.model.__name__.lower() url = '/add/{}/{}/?{}='.format(app_label, model_name, start_field) link = dict(label=label, url=url) self.links.append(link) self.models.append(queryset.model)
def delete(self, *args, **kwargs): log_data = get_metadata(self.__class__, 'log', False) log_index = get_metadata(self.__class__, 'logging', ()) if (log_data or log_index) and self._user: from djangoplus.admin.models import Log collector = Collector(using='default') collector.collect([self], keep_parents=False) for cls, objs in collector.data.items(): content_type = ContentType.objects.get_for_model(cls) for obj in objs: log = Log() log.operation = Log.DELETE log.user = self._user log.content_type = content_type log.object_id = obj.pk log.object_description = unicode(obj) diff = [] for field in get_metadata(obj.__class__, 'fields'): if not isinstance(field, models.FileField): o1 = getattr(obj, field.name) v1 = unicode(o1) diff.append((field.verbose_name, v1)) log.content = json.dumps(diff) log.save() log.create_indexes(obj) super(Model, self).delete(*args, **kwargs) self.check_role(False)
def all(self, user=None, obj=None): app_label = get_metadata(self.model, 'app_label') if user: role_username = get_metadata(user, 'role_username') if role_username: user = get_user_model().objects.get( username=getattr(user, role_username)) queryset = self._clone() queryset.user = user if user: has_perm = obj and True or user.has_perm( '%s.list_%s' % (app_label, self.model.__name__.lower())) else: has_perm = True if has_perm: if user and (user.organization_id or user.unit_id or not user.is_superuser): permission_mapping = user.get_permission_mapping( self.model, obj) if 'list_lookups' in permission_mapping and permission_mapping[ 'list_lookups']: l = [] for lookup, value in permission_mapping['list_lookups']: l.append(Q(**{'%s__in' % lookup: value})) return queryset.filter(reduce(OR, l)) return queryset return self.none()
def all(self, user=None, obj=None): app_label = get_metadata(self.model, 'app_label') if user: role_username = get_metadata(user, 'role_username') if role_username: user = get_user_model().objects.get( username=getattr(user, role_username)) queryset = self._clone() queryset._user = user if user: self_permission = '{}.view_{}'.format(app_label, self.model.__name__.lower()) obj_permission = obj and '{}.view_{}'.format( get_metadata(type(obj), 'app_label'), type(obj).__name__.lower()) has_perm = obj_permission and user.has_perm( obj_permission) or user.has_perm(self_permission) else: has_perm = True if has_perm: if user and not user.is_superuser: permission_mapping = user.get_permission_mapping( self.model, obj) if 'list_lookups' in permission_mapping and permission_mapping[ 'list_lookups']: l = [] for lookup, value in permission_mapping['list_lookups']: l.append(Q(**{'{}__in'.format(lookup): value})) return queryset.filter(reduce(OR, l)) return queryset return self.none()
def reload_options(request, app_name, class_name, current_value, lookup, selected_value, lazy): l = [] pks = [] if not current_value == '0': for pk in current_value.split('_'): pks.append(int(pk)) selected_value = int(selected_value) lazy = int(lazy) cls = apps.get_model(app_name, class_name) select_template = get_metadata(cls, 'select_template') select_display = get_metadata(cls, 'select_display') queryset = cls.objects.filter(**{lookup: selected_value}) data = dict(selected_value=selected_value, results=[], qs=lazy and dumps_qs_query(queryset) or None) if lazy: if pks: for obj in cls.objects.filter(pk__in=pks): html = (select_template or select_display) and render_to_string(select_template or 'select_template.html', dict(obj=obj, select_display=select_display)) or str(obj) data['results'].append(dict(id=obj.id, text=str(obj), html=html)) else: for obj in queryset: html = (select_template or select_display) and render_to_string(select_template or 'select_template.html', dict(obj=obj, select_display=select_display)) or str(obj) data['results'].append(dict(id=obj.id, text=str(obj), html=html)) s = json.dumps(data) return HttpResponse(s)
def contextualize(self, user, obj=None): app_label = get_metadata(self.model, 'app_label') if user and user.is_authenticated: role_username = get_metadata(user, 'role_username') if role_username: user = get_user_model().objects.get( username=getattr(user, role_username)) queryset = self._clone() queryset._user = user if user: self_permission = '{}.view_{}'.format(app_label, self.model.__name__.lower()) obj_permission = obj and '{}.view_{}'.format( get_metadata(type(obj), 'app_label'), type(obj).__name__.lower()) has_perm = obj_permission and user.has_perm( obj_permission) or user.has_perm(self_permission) else: has_perm = True if has_perm: if user and not user.is_superuser: queryset = user.apply_current_scope(queryset) permission_mapping = user.get_permission_mapping( self.model, obj) if 'list_lookups' in permission_mapping and permission_mapping[ 'list_lookups']: lookups = [] for lookup, value in permission_mapping['list_lookups']: lookups.append(Q(**{'{}__in'.format(lookup): value})) return queryset.filter(reduce(operator.__or__, lookups)).distinct() return queryset return self.none()
def tolist(qs, add_header=True, list_display=()): model = qs.model data = [] fields = [] header = [] if type(list_display) == bool or not list_display: list_display = get_metadata(model, 'list_display', fields) if list_display: for field_name in list_display: header.append(get_fiendly_name(model, field_name)) fields.append(field_name) else: for field in get_metadata(model, 'fields'): header.append(field.verbose_name) fields.append(field.name) if add_header: data.append(header) for obj in qs: row = [] for field in fields: val = getattr2(obj, field) if callable(val): val = val() row.append(format_value(val, False)) data.append(row) return data
class Meta: model = loader.signup_model fields = get_metadata(loader.signup_model, 'form_fields', '__all__') exclude = get_metadata(loader.signup_model, 'exclude_fields', ()) submit_label = 'Cadastrar' title = 'Cadastro de %s' % get_metadata(loader.signup_model, 'verbose_name') icon = get_metadata(loader.signup_model, 'icon', None)
def __init__(self, request, qs, title=None, list_display=None, list_filter=None, search_fields=None, list_per_page=25, list_subsets=None, exclude=None, relation=None, readonly=False, is_list_view=False, help_text=None, url=None, template='datagrid.html', uid=None): super(Paginator, self).__init__(is_list_view and '_' or abs(hash(title)), request) if relation: qs = qs.model.objects.filter(pk__in=qs.values_list('pk', flat=True)) else: qs = qs.all() self.qs = qs self.title = title self.list_display = list_display self.list_filter = list_filter self.search_fields = search_fields self.list_per_page = list_per_page self.subsets = None self.exclude = exclude self.relation = relation self.readonly = readonly self.is_list_view = is_list_view self.icon = get_metadata(qs.model, 'icon', None) self.list_total = get_metadata(qs.model, 'list_total', None) self.ordering = get_metadata(qs.model, 'ordering', None) self.template = get_metadata(self.qs.model, 'list_template', template) self.help_text = help_text self.url = url self.display_checkboxes = False self.action_names = None self.filters = [] self.pagination = '' self.original_qs = qs self.count = None # tabs self.tabs = [] self.current_tab = self._get_from_request('tab', None) if list_subsets is not None: self.subsets = OrderedDict() for subset_name in list_subsets: self.subsets[subset_name] = {} self._load_tabs() # list display self._configure_list_display() # column names self.column_names = [] self._configure_column_names() # drop down self.class_dropdown = GroupDropDown(request, style='class-action') self.queryset_dropdown = GroupDropDown(request, style='queryset-action disabled') self.drop_down = ModelDropDown(request, qs.model) self.mobile = mobile(self.request) if hasattr(self.qs, 'permission_map'): self.permission_map = self.qs.permission_map self.qs = self._filter_queryset(self.qs)
def render(self, name, value, attrs=None, renderer=None, choices=()): has_id = attrs and 'id' in attrs final_attrs = self.build_attrs(attrs) values = value and (type(value) == int and [value] or [int(v) for v in value]) or [] widget_cls = self.allow_multiple_selected and CheckboxInput or RadioSelect i = 0 grouped_objects = [] onclick = "var is=this.parentNode.parentNode.parentNode.parentNode.parentNode.getElementsByTagName('input');" \ "for(var i=0; i<is.length; i++) is[i].checked = {}".format( self.allow_multiple_selected and 'this.checked' or 'false') widget = widget_cls({ 'onclick': onclick }, check_test=lambda v: False).render(None, '') extra_display = [] if self.choices: qs = hasattr( self.choices.queryset, 'all') and self.choices.queryset.all() or self.choices.queryset select_display = get_metadata(qs.model, 'select_display') if select_display: for lookup in get_metadata(qs.model, 'select_display', []): extra_display.append( (get_fiendly_name(qs.model, lookup, as_tuple=False), lookup)) else: extra_display.append((None, '__str__')) if self.grouper: groupers = qs.values_list(self.grouper, flat=True).order_by( self.grouper).distinct() else: groupers = [None] for grouper in groupers: objects = [] if grouper: grouped_qs = qs.filter(**{self.grouper: grouper}) else: grouped_qs = qs.all() for obj in grouped_qs: option_value = obj.pk if has_id: final_attrs = dict(final_attrs, id='{}_{}'.format(attrs['id'], i)) final_attrs[ 'class'] = self.allow_multiple_selected and 'custom-checkbox' or 'custom-radio' obj.widget = widget_cls( final_attrs, check_test=lambda v: int(v) in values).render( name, str(option_value)) i += 1 objects.append(obj) grouped_objects.append((grouper, objects)) return mark_safe( render_to_string( self.template_name, dict(grouped_objects=grouped_objects, widget=widget, extra_display=extra_display, name=name.replace('-', '_'))))
def autocomplete(request, app_name, class_name): results = [] q = request.POST['q'] qs = loads_qs_query(request.POST['qs[qs]']) search_fields = get_metadata(qs.model, 'search_fields', []) select_template = get_metadata(qs.model, 'select_template') select_display = get_metadata(qs.model, 'select_display') queryset = None if q: for i, search_field in enumerate(search_fields): if i == 0: queryset = qs.filter(**{'%s__icontains' % search_field: q}) else: queryset = queryset | qs.filter( **{'%s__icontains' % search_field: q}) if queryset is None: raise ValueError('The class %s does not have any search field.' % class_name) else: queryset = qs queryset = queryset.all(request.user) for obj in queryset[0:25]: html = (select_template or select_display) and render_to_string( select_template or 'select_template.html', dict(obj=obj, select_display=select_display)) or unicode(obj) results.append(dict(id=obj.id, text=unicode(obj), html=html)) s = json.dumps(dict(q=q, results=results)) return HttpResponse(s)
def __init__(self, request, title, qs, list_display=(), list_filter=()): super(ModelReport, self).__init__(request) self.title = title self.qs = qs self.components = [] if list_filter: form = forms.Form(request) form.icon = 'fa-file-text-o' form.title = u'' form.submit_label = u'Gerar Relatório' for field_name in list_filter: field = get_field(qs.model, field_name) form.fields[field_name] = forms.ModelChoiceField( field.rel.to.objects.all(), label=field.verbose_name, required=False) if form.is_valid(): for field_name in list_filter: value = form.cleaned_data[field_name] if value: qs = qs.filter(**{field_name: value}) self.form = form order_by = get_metadata(qs.model, 'order_by', iterable=True) if order_by: qs = qs.order_by(*order_by) table_description = get_metadata(qs.model, 'verbose_name_plural') self.table = ModelTable(request, table_description, qs, list_display)
def add_widget(self, obj, item): model = item['model'] title = item['verbose_name'] func_name = item['function'] dashboard = item['dashboard'] list_display = item.get('list_display') link = item['link'] l = [] if dashboard: if type(dashboard) == dict: for position, group_names in list(dashboard.items()): group_names = type( group_names) == tuple and group_names or ( group_names, ) l.append((position, group_names)) else: l.append((dashboard, item['can_view'])) for position, group_names in l: if permissions.check_group_or_permission( self.request, group_names, ignore_superuser=True): func = getattr(obj, func_name) f_return = execute_and_format(self.request, func) if type(f_return) in (int, Decimal): verbose_name = get_metadata(model, 'verbose_name_plural') icon = get_metadata(model, 'icon') panel = NumberPanel(self.request, verbose_name, f_return, title, icon) html = str(panel) elif hasattr(f_return, 'model'): compact = position in ('left', 'right') app_label = get_metadata(model, 'app_label') model_name = model.__name__.lower() verbose_name_plural = get_metadata( model, 'verbose_name_plural') if link: title = '{} {}'.format(verbose_name_plural, title) url = '/list/{}/{}/{}/'.format(app_label, model_name, func_name) paginator = Paginator(self.request, f_return, title, readonly=compact, list_display=list_display, list_filter=(), search_fields=(), list_subsets=[func_name], url=link and url or None) if compact and not paginator.template: paginator.column_names = paginator.column_names[ 0:1] html = str(paginator) else: html = str(f_return) self.add(html, position)
def get_register_form(request, obj): _model = type(obj) initial = hasattr(obj, 'initial') and obj.initial() or {} choices = hasattr(obj, 'choices') and obj.choices() or {} form_name = get_metadata(_model, 'add_form') app_label = get_metadata(_model, 'app_label') verbose_name = get_metadata(_model, 'verbose_name') role_username = get_metadata(_model, 'role_username', None) if form_name: full_app_name = settings.APP_MAPPING.get(app_label, app_label) forms_module = __import__('{}.forms'.format(full_app_name), fromlist=list(map(str, [app_label]))) Form = getattr(forms_module, form_name) else: if obj.pk: form_title = '{} {}'.format(_('Edit'), str(verbose_name)) button_label = _('Save') else: add_label = get_metadata(_model, 'add_label', None) form_title = add_label or '{} {}'.format(_('Register'), str(verbose_name)) button_label = add_label or _('Save') class Form(forms.ModelForm): class Meta: model = _model fields = get_metadata(_model, 'form_fields', '__all__') exclude = get_metadata(_model, 'exclude_fields', ()) submit_label = button_label title = form_title icon = get_metadata(_model, 'icon', None) perm_or_group = '{}.add_{}'.format(app_label, _model.__name__.lower()) class Media: js = get_js(_model) form = Form(request, instance=obj, initial=initial) form.name = '{}Form'.format(_model.__name__) for field_name in choices: form.fields[field_name].queryset = choices[field_name] form.fields[field_name].widget.queryset = choices[field_name] if hasattr(obj, 'get_parent_field'): parent_field = obj.get_parent_field() if parent_field: if not obj.pk and parent_field.name in form.fields: form.fields[ parent_field.name].widget = forms.widgets.HiddenInput() if role_username and obj.pk: if role_username in form.fields: form.fields[role_username].widget = forms.widgets.ReadOnlyInput() return form
class Meta: model = CACHE['SIGNUP_MODEL'] fields = get_metadata(CACHE['SIGNUP_MODEL'], 'form_fields', '__all__') exclude = get_metadata(CACHE['SIGNUP_MODEL'], 'exclude_fields', ()) submit_label = _('Register') title = '{} {}'.format(_('Register'), get_metadata(CACHE['SIGNUP_MODEL'], 'verbose_name')) icon = get_metadata(CACHE['SIGNUP_MODEL'], 'icon', None) captcha = settings.CAPTCHA_KEY and settings.CAPTCHA_SECRET and 'test' not in sys.argv or False
class Meta: model = rel.to fields = get_metadata(rel.to, 'form_fields', '__all__') exclude = get_metadata(rel.to, 'exclude_fields', ()) submit_label = u'Adicionar %s' % get_metadata( rel.to, 'verbose_name') title = u'Adicionar %s' % get_metadata(rel.to, 'verbose_name') icon = get_metadata(rel.to, 'icon', None)
class Meta: model = related_field.rel.to fields = get_metadata(related_field.rel.to, 'form_fields', '__all__') exclude = get_metadata(related_field.rel.to, 'exclude_fields', ()) submit_label = 'Atualizar %s' % related_field.verbose_name title = u'Atualizar %s' % related_field.verbose_name icon = get_metadata(related_field.rel.to, 'icon', None)
def load_widgets(self): from djangoplus.cache import CACHE for model in CACHE['SUBSETS']: notification_panels = {} icon = get_metadata(model, 'icon', 'fa-bell-o') title = get_metadata(model, 'verbose_name_plural') app_label = get_metadata(model, 'app_label') model_name = model.__name__.lower() for item in CACHE['SUBSETS'][model]: description = item['verbose_name'] notify = item['notify'] if notify is True or notify and permissions.check_group_or_permission( self.request, notify): attr_name = item['function'].__func__.__name__ qs = model.objects.all(self.request.user) qs = getattr(qs, attr_name)() count = qs.count() if count: url = '/list/{}/{}/{}/'.format(app_label, model_name, attr_name) if model_name in notification_panels: notification_panel = notification_panels[ model_name] else: notification_panel = NotificationPanel( self.request, title, icon) self.right.append(notification_panel) notification_panels[ model_name] = notification_panel notification_panel.add(count, url, description) for model in CACHE['LIST_DASHBOARD']: title = get_metadata(model, 'verbose_name_plural') position = get_metadata(model, 'dashboard') paginator = Paginator(self.request, model.objects.all(self.request.user), title) self.add(paginator, position) icon_panel = ShortcutPanel(self.request) card_panel = CardPanel(self.request) self.top.append(icon_panel) self.center.append(card_panel) for item in CACHE['SUBSET_WIDGETS']: self.add_widget(item['model'].objects.all(self.request.user), item) for item in CACHE['WIDGETS']: if permissions.check_group_or_permission(self.request, item['can_view'], ignore_superuser=True): func = item['function'] position = item['position'] f_return = func(self.request) html = render_to_string( ['{}.html'.format(func.__name__), 'dashboard.html'], f_return, self.request) self.add(html, position)
def __init__(self, request, qs, title=None, list_display=None, list_filter=None, search_fields=None, list_per_page=25, list_subsets=None, exclude=None, to=None, readonly=False, is_list_view=False): super(Paginator, self).__init__(request) self.id = abs(hash(title)) self.qs = qs.all() self.title = title self.list_display = list_display self.list_filter = list_filter self.search_fields = search_fields self.list_per_page = list_per_page self.list_subsets = list_subsets self.exclude = exclude self.to = to self.readonly = readonly self.is_list_view = is_list_view self.icon = get_metadata(qs.model, 'icon', None) self.list_total = get_metadata(qs.model, 'list_total', None) self.subset_actions = [] self.filters = [] self.pagination = '' self.original_qs = qs # list display self._configure_list_display() # column names self.column_names = [] self._configure_column_names() # tabs self.tabs = [] self.current_tab = self._get_from_request('tab', None) self._load_tabs() # drop down self.paginator_dropdown = GroupDropDown(request) self.subset_dropdown = GroupDropDown(request) self.drop_down = ModelDropDown(request, qs.model) self.mobile = mobile(self.request) if hasattr(self.qs, 'permission_map'): self.permission_map = self.qs.permission_map self.qs = self._filter_queryset(self.qs)
class Meta: model = _model fields = get_metadata(_model, 'form_fields', '__all__') exclude = get_metadata(_model, 'exclude_fields', ()) submit_label = button_label title = form_title icon = get_metadata(_model, 'icon', None) perm_or_group = '{}.add_{}'.format(app_label, _model.__name__.lower())
class Meta: model = self.relation_model fields = get_metadata(self.relation_model, 'form_fields', '__all__') exclude = get_metadata(self.relation_model, 'exclude_fields', ()) submit_label = 'Adicionar' title = 'Adicionar {}'.format( relation_verbose_name)
def add_models(self, *models): for model in models: icon = get_metadata(model, 'icon') title = get_metadata(model, 'verbose_name_plural') app_label = get_metadata(model, 'app_label') model_name = model.__name__.lower() url = '/list/{}/{}/'.format(app_label, model_name) permission = '{}.list_{}'.format(app_label, model_name) self.add(icon, title, None, url, '', permission)
def add_models(self, *models): for model in models: icon = get_metadata(model, 'icon') title = get_metadata(model, 'verbose_name_plural') app_label = get_metadata(model, 'app_label') model_name = model.__name__.lower() url = '/list/%s/%s/' % (app_label, model_name) permission = '%s.list_%s' % (app_label, model_name) self.add(icon, title, None, url, u'bg-info', permission)
def get_many_to_one_form(request, obj, related_field_name, related_obj): _model = type(obj) rel = getattr(_model, related_field_name.split(':')[0].split('__')[0]).rel add_label = get_metadata(rel.related_model, 'add_label') if add_label: form_title = add_label button_label = add_label else: title = _('Add ') action = _('Save') form_title = '{} {}'.format( title, get_metadata(rel.related_model, 'verbose_name')) button_label = action related_field_name = rel.field.name setattr(related_obj, related_field_name, obj) initial = hasattr(related_obj, 'initial') and related_obj.initial() or {} choices = hasattr(related_obj, 'choices') and related_obj.choices() or {} app_label = get_metadata(_model, 'app_label') form_name = get_metadata(rel.related_model, 'add_form') if form_name: full_app_name = settings.APP_MAPPING.get(app_label, app_label) forms_module = __import__('{}.forms'.format(full_app_name), fromlist=list(map(str, [app_label]))) Form = getattr(forms_module, form_name) else: class Form(forms.ModelForm): class Meta: model = rel.related_model fields = get_metadata(rel.related_model, 'form_fields', '__all__') exclude = get_metadata(rel.related_model, 'exclude_fields', ()) submit_label = related_obj.pk and 'Atualizar' or button_label title = form_title is_inner = True class Media: js = get_js(rel.related_model) initial[related_field_name] = obj.pk for key in list(initial.keys()): if hasattr(obj, key) and obj.pk and getattr(obj, key): del (initial[key]) form = Form(request, initial=initial, instance=related_obj) form.form_name = '{}Form'.format(rel.related_model.__name__) for field_name in choices: if field_name in form.fields: form.fields[field_name].queryset = choices[field_name] if related_field_name in form.fields: del (form.fields[related_field_name]) return form
class Meta: model = related_field.remote_field.model fields = get_metadata(related_field.remote_field.model, 'form_fields', '__all__') exclude = get_metadata(related_field.remote_field.model, 'exclude_fields', ()) submit_label = 'Atualizar {}'.format(related_field.verbose_name) title = 'Atualizar {}'.format(related_field.verbose_name) icon = get_metadata(related_field.remote_field.model, 'icon', None) is_inner = True
def get_register_form(request, obj): _model = type(obj) initial = hasattr(obj, 'initial') and obj.initial() or {} choices = hasattr(obj, 'choices') and obj.choices() or {} form_name = get_metadata(_model, 'add_form') app_label = get_metadata(_model, 'app_label') verbose_name = get_metadata(_model, 'verbose_name') role_username = get_metadata(_model, 'role_username', None) if form_name: full_app_name = settings.APP_MAPPING.get(app_label, app_label) forms_module = __import__('%s.forms' % full_app_name, fromlist=app_label) Form = getattr(forms_module, form_name) else: if obj.pk: form_title = u'Atualização de %s' % unicode(verbose_name) button_label = u'Atualizar' else: add_label = get_metadata(_model, 'add_label', None) form_title = add_label or u'Cadastro de %s' % unicode(verbose_name) button_label = add_label or u'Cadastrar' class Form(forms.ModelForm): class Meta: model = _model fields = get_metadata(_model, 'form_fields', '__all__') exclude = get_metadata(_model, 'exclude_fields', ()) submit_label = button_label title = form_title icon = get_metadata(_model, 'icon', None) perm_or_group = '%s.add_%s' % (app_label, _model.__name__.lower()) form = Form(request, instance=obj, initial=initial) form.name = u'%sForm' % _model.__name__ for field_name in choices: form.fields[field_name].queryset = choices[field_name] form.fields[field_name].widget.queryset = choices[field_name] if hasattr(obj, 'get_parent_field'): parent_field = obj.get_parent_field() if parent_field: if not obj.pk and parent_field.name in form.fields: form.fields[ parent_field.name].widget = forms.widgets.HiddenInput() if role_username and obj.pk: if role_username in form.fields: form.fields[role_username].widget = forms.widgets.ReadOnlyInput() return form
def _find(self, model, registering=False): click_str = [] click_str_unicode = [] verbose_name_plural = get_metadata(model, 'verbose_name_plural') list_shortcut = get_metadata(model, 'list_shortcut', [], iterable=True) list_menu = get_metadata(model, 'list_menu', [], iterable=True) dashboard = get_metadata(model, 'dashboard') menu = get_metadata(model, 'menu') # list_required_role = [role_name for role_name in (list_shortcut + list_menu) if role_name is not True] # if list_required_role and CACHE['LAST_AUTHENTICATED_ROLE'] and CACHE['LAST_AUTHENTICATED_ROLE'] not in list_required_role: # self._login('{} {} {}'.format(_('Access'), _('as'), list_required_role[0])) if dashboard and not registering: panel_title = verbose_name_plural interaction = _('The user looks at the painel') self._interactions.append('{} "{}"'.format(interaction, panel_title)) self._test_function_code.append( " self.look_at_panel('{}')".format(panel_title)) return True elif not CACHE[ 'LAST_AUTHENTICATED_ROLE'] or True in list_shortcut or CACHE[ 'LAST_AUTHENTICATED_ROLE'] in list_shortcut: left = _('The user clicks on the shortcut card') right = _('in the dashboard at main page') interaction = '{} "{}" {}'.format(left, verbose_name_plural, right) self._interactions.append(interaction) self._interactions.append( _('The system displays the listing page')) self._test_function_code.append( ' self.click_link(u\'{}\')'.format(verbose_name_plural)) return True elif menu: if type(menu) == tuple: menu = menu[0] for menu_item in menu.split('::'): click_str.append('"{}"'.format(menu_item)) click_str_unicode.append("'{}'".format(menu_item)) interaction = _('The user access the menu') self._interactions.append('{} {}'.format(interaction, ', '.join(click_str))) self._test_function_code.append( ' self.click_menu({})'.format( ', '.join(click_str_unicode))) return True return False
def _view(self, model, recursive=False): list_shortcut = get_metadata(model, 'list_shortcut', []) list_menu = get_metadata(model, 'list_menu') # if the model can be accessed by the menu or shortcut if list_shortcut or list_menu: self._find(model) self._interactions.append( _(u'The user locates the record and clicks the visualization icon' )) self._interactions.append( _(u'The system displays the visualization page')) self._test_function_code.append(u"\t\tself.click_icon(u'%s')" % u'Visualizar') # _(u'Visualize') else: # the model can be accesses only by a parent model for parent_model in loader.composition_relations: if model in loader.composition_relations[parent_model]: self._view(parent_model, True) panel_title = None if hasattr(parent_model, 'fieldsets'): for fieldset in parent_model.fieldsets: if 'relations' in fieldset[1]: for item in fieldset[1]['relations']: relation = getattr(parent_model, item) if relation.rel.related_model == model: panel_title = fieldset[0] break if panel_title: if '::' in panel_title: tab_name, panel_title = panel_title.split('::') self._test_function_code.append( u"\t\tself.click_tab(u'%s')" % tab_name) interaction = _(u'The user clicks the tab') self._interactions.append(u'%s "%s"' % (interaction, tab_name)) if panel_title: interaction = _(u'The user looks at the painel') self._interactions.append( u'%s "%s"' % (interaction, panel_title)) self._test_function_code.append( u"\t\tself.look_at_panel(u'%s')" % panel_title) if recursive: self._interactions.append( _(u'The user locates the record and clicks the visualization icon' )) self._interactions.append( _(u'The system displays the visualization page')) self._test_function_code.append( u"\t\tself.click_icon(u'%s')" % u'Visualizar') # _(u'Visualize')
def get_many_to_one_form(request, obj, related_field_name, related_obj): _model = type(obj) rel = getattr(_model, related_field_name).field.rel add_label = get_metadata(rel.related_model, 'add_label') if add_label: form_title = add_label button_label = add_label else: action = related_obj.pk and u'Atualizar' or u'Adicionar' form_title = u'%s %s' % ( action, get_metadata(rel.related_model, 'verbose_name')) button_label = action related_field_name = rel.field.name setattr(related_obj, related_field_name, obj) initial = hasattr(related_obj, 'initial') and related_obj.initial() or {} choices = hasattr(related_obj, 'choices') and related_obj.choices() or {} app_label = get_metadata(_model, 'app_label') form_name = get_metadata(rel.related_model, 'add_form') if form_name: full_app_name = settings.APP_MAPPING.get(app_label, app_label) forms_module = __import__('%s.forms' % full_app_name, fromlist=app_label) Form = getattr(forms_module, form_name) else: class Form(forms.ModelForm): class Meta: model = rel.related_model fields = get_metadata(rel.related_model, 'form_fields', '__all__') exclude = get_metadata(rel.related_model, 'exclude_fields', ()) submit_label = related_obj.pk and u'Atualizar' or button_label title = form_title initial[related_field_name] = obj.pk for key in initial.keys(): if hasattr(obj, key) and obj.pk and getattr(obj, key): del (initial[key]) form = Form(request, initial=initial, instance=related_obj) form.form_name = u'%sForm' % rel.related_model.__name__ for field_name in choices: if field_name in form.fields: form.fields[field_name].queryset = choices[field_name] if related_field_name in form.fields: del (form.fields[related_field_name]) return form