def _signup(self, action):
model_name = action.split('como')[1].strip()
model = find_model_by_verbose_name(model_name)
func_name = slugify(action).replace('-', '_')
func_decorator = '@testcase(\'{}\', None)'.format(self.name)
self._func_signature = '{}(self)'.format(func_name)
self._test_function_code.append(' {}'.format(func_decorator))
self._test_function_code.append(' def {}:'.format(
self._func_signature))
interaction = _('The user access login page')
self._interactions.append(interaction)
self._test_function_code.append(" self.open('/admin/login')")
interaction = _('The user clicks the link')
self._interactions.append('{} "{}"'.format(interaction, _('Sign-up')))
self._test_function_code.append(
" self.click_button('{}')".format(_('Sign-up')))
self._interactions.append(_('The system displays a popup window'))
self._test_function_code.append(" self.look_at_popup_window()")
form = factory.get_register_form(self._mocked_request(), model())
self._fill_out(form)
interaction = _('The user clicks the button')
self._interactions.append('{} "{}"'.format(interaction, _('Register')))
self._test_function_code.append(
" self.click_button('{}')".format(_('Register')))
def add(request, app, cls, pk=None, related_field_name=None, related_pk=None):
if not request.user.is_authenticated:
return httprr(request,
'/admin/login/?next={}'.format(request.get_full_path()))
try:
_model = apps.get_model(app, cls)
except LookupError as e:
return page_not_found(request, e, 'error404.html')
obj = pk and _model.objects.all(
request.user).filter(pk=pk).first() or _model()
obj.request = request
obj._user = request.user
title = pk and str(obj) or get_metadata(_model, 'verbose_name')
if related_field_name is None:
if obj.pk:
if not permissions.has_edit_permission(
request, _model) or not permissions.can_edit(request, obj):
return HttpResponseForbidden()
else:
if not permissions.has_add_permission(
request, _model) or not permissions.can_add(request, obj):
return HttpResponseForbidden()
form = factory.get_register_form(request, obj)
title = form.title
elif is_one_to_many(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_one_to_many_form(request, obj, related_field_name)
elif is_many_to_many(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_many_to_many_form(request, obj, related_field_name,
related_pk)
elif is_one_to_many_reverse(_model, related_field_name):
form = factory.get_many_to_many_reverse_form(request, obj,
related_field_name)
elif is_one_to_one(_model, related_field_name):
if not permissions.can_add(request, obj) and not permissions.can_edit(
request, obj):
return HttpResponseForbidden()
form = factory.get_one_to_one_form(request, obj, related_field_name,
related_pk)
else:
# many to one
for rel in list_related_objects(_model):
if hasattr(rel, 'get_accessor_name'):
if rel.get_accessor_name() in (
'{}_set'.format(related_field_name),
related_field_name):
related_queryset = rel.related_model.objects.all(
request.user)
related_obj = related_pk and related_queryset.get(
pk=related_pk) or rel.related_model()
related_obj.request = request
setattr(related_obj, rel.field.name, obj)
setattr(related_obj, '{}_id'.format(rel.field.name),
obj.pk)
if related_pk:
if not permissions.has_edit_permission(
request,
rel.related_model) or not permissions.can_edit(
request, related_obj):
return HttpResponseForbidden()
else:
if not permissions.has_add_permission(
request,
rel.related_model) or not permissions.can_add(
request, related_obj):
return HttpResponseForbidden()
form = factory.get_many_to_one_form(
request, obj, rel.get_accessor_name(), related_obj)
title = form.title
if form.is_valid():
is_editing = form.instance.pk is not None
try:
form.save()
obj = form.instance
if 'select' in request.GET:
return HttpResponse('{}|{}|{}'.format(obj.pk, obj,
request.GET['select']))
elif related_field_name:
message = 'Ação realizada com sucesso'
url = '..'
else:
message = get_metadata(form.instance.__class__, 'add_message')
if message and not is_editing:
if hasattr(obj, 'get_absolute_url'):
url = obj.get_absolute_url()
else:
url = '/view/{}/{}/{}/'.format(
get_metadata(obj.__class__, 'app_label'),
obj.__class__.__name__.lower(), obj.pk)
else:
url = '..'
if is_editing:
message = message or 'Atualização realizada com sucesso'
else:
message = message or 'Cadastro realizado com sucesso'
return httprr(request, url, message)
except ValidationError as e:
form.add_error(None, str(e.message))
return render(request, 'default.html', locals())
def _register(self, action):
model = find_model_by_add_label(action)
if model:
verbose_name = get_metadata(model, 'verbose_name')
button_label = get_metadata(model, 'add_label')
save_button_label = get_metadata(model, 'add_label', _('Save'))
func_name = slugify(button_label).replace('-', '_')
else:
verbose_name = action.replace(_('Register'), '').strip()
model = find_model_by_verbose_name(verbose_name)
button_label = _('Register')
save_button_label = _('Save')
func_name = 'cadastrar_{}'.format(model.__name__.lower())
# set the attributes of the usecase
self.name = action
self.description = '{} {} {}'.format(_('Add new records of'),
verbose_name.lower(),
_('in the system'))
self.business_rules = utils.extract_exception_messages(model.save)
self.post_condition = _(
'The record will be successfully registered in the system')
required_data = []
for field in get_metadata(model, 'get_fields'):
if isinstance(field, model_fields.ForeignKey):
if not isinstance(field, model_fields.OneToOneField):
if not isinstance(field, model_fields.OneToManyField):
required_data.append(field.verbose_name.lower())
if required_data:
pre_condition = _(
'The following information must have been previouly registered in the system: '
)
self.pre_conditions.append('{} {}'.format(
pre_condition, ', '.join(required_data)))
for meta_data in ('can_admin', 'can_admin_by_role',
'can_admin_by_unit', 'can_admin_by_organization',
'can_add', 'can_add_by_role', 'can_add_by_unit',
'can_add_by_organization'):
for actor in get_metadata(model, meta_data, iterable=True):
if actor:
self.actors.append(actor)
if not self.actors:
self.actors.append(_('Superuser'))
# register the interactions and testing code'
username_attr = ''
if CACHE['LAST_AUTHENTICATED_USERNAME']:
username_attr = ", '{}'".format(
CACHE['LAST_AUTHENTICATED_USERNAME'])
func_decorator = '@testcase(\'{}\'{})'.format(self.name, username_attr)
self._func_signature = '{}(self)'.format(func_name)
self._test_function_code.append(' {}'.format(func_decorator))
self._test_function_code.append(' def {}:'.format(
self._func_signature))
self._find(model, registering=True)
self._test_function_code.append(
" self.click_button('{}')".format(button_label))
a = _('The user clicks the button')
b = _('on the right-side of the action bar')
self._interactions.append('{} "{}" {}'.format(a, button_label, b))
form = factory.get_register_form(self._mocked_request(), model())
self._fill_out(form)
interaction = _('The user clicks the button')
self._interactions.append('{} "{}"'.format(interaction,
save_button_label))
self._test_function_code.append(
" self.click_button('{}')".format(save_button_label))
self._test_function_code.append(
" self.click_icon('{}')".format('Principal'))
def api(request, app_label, model_name, arg1=None, arg2=None):
from djangoplus.admin.models import User
obj = None
form = None
result = None
errors = None
func_name = None
message = None
args = {}
http_authorization = request.META.get('HTTP_AUTHORIZATION')
if http_authorization and 'Token' in http_authorization:
page= int(request.GET.get('page', '') or 0)
token = http_authorization[5:].strip()
user = User.objects.get(token=token)
request.user = user
if app_label and model_name:
model = apps.get_model(app_label, model_name)
if model == User and str(user.pk) == arg1:
data = dict(name=user.name, username=user.username, photo=user.photo.url, email=user.email)
return HttpResponse(
json_serialize(result, request.GET, errors=[], message=_('Action successfully performed.'), exception=None, result=data)
)
# model @action or @meta | manager @subset [@action or @meta]
elif arg1 and arg2:
# model
if arg1.isdigit():
obj = model.objects.all(user).get(pk=arg1)
if arg2:
# @action
group = None
for group in CACHE['INSTANCE_ACTIONS'][model]:
if arg2 in CACHE['INSTANCE_ACTIONS'][model][group]:
action_dict = CACHE['INSTANCE_ACTIONS'][model][group][arg2]
message = action_dict.get('message')
func_name = arg2
break
if func_name:
func = getattr(obj, func_name)
form_action = CACHE['INSTANCE_ACTIONS'][model][group][arg2]
# with input
if count_parameters_names(func) > 0:
form = factory.get_action_form(request, obj, form_action)
# it is not @action
else:
# @meta
for method in CACHE['INSTANCE_METHODS'].get(model, []):
if method['function'] == arg2:
func_name = arg2
func = getattr(obj, func_name)
break
# manager @subset
else:
obj = model.objects.all(user)
pks = request.GET.get('ids', [])
if pks:
obj = obj.filter(pk__in=pks)
group = None
# @action
for group in CACHE['QUERYSET_ACTIONS'][model]:
if arg2 in CACHE['QUERYSET_ACTIONS'][model][group]:
action_dict = CACHE['QUERYSET_ACTIONS'][model][group][arg2]
message = action_dict.get('message')
func_name = arg2
break
if func_name:
func = getattr(obj, func_name)
form_action = CACHE['QUERYSET_ACTIONS'][model][group][arg2]
# with input
if count_parameters_names(func) > 0:
form = factory.get_class_action_form(request, obj.model, form_action, func)
# it is not @action
else:
# @meta
for method in CACHE['MANAGER_METHODS'].get(model, []):
if method['function'] == arg1:
func_name = arg2
func = getattr(obj, func_name)
break
# model | manager @subset or @action or @meta
elif arg1:
if arg1.isdigit():
# model
obj = model.objects.all(user).get(pk=arg1)
if request.method.lower() == 'get':
result = obj
elif request.method.lower() == 'delete':
result = None
obj.delete()
message = _('Deletion successfully performed.')
else:
form = factory.get_register_form(request, obj)
else:
# manager @subset or @action or @meta
obj = model.objects.all(user)
pks = request.GET.get('ids', [])
if pks:
obj = obj.filter(pk__in=pks)
group = None
# @action
func = None
action_dict = None
for group in CACHE['QUERYSET_ACTIONS'][model]:
if arg1 in CACHE['QUERYSET_ACTIONS'][model][group]:
action_dict = CACHE['QUERYSET_ACTIONS'][model][group][arg1]
message = action_dict.get('message')
func = getattr(obj, arg1)
func_name = arg1
break
if not func_name:
for group in CACHE['CLASS_ACTIONS'][model]:
if arg1 in CACHE['CLASS_ACTIONS'][model][group]:
action_dict = CACHE['CLASS_ACTIONS'][model][group][arg1]
message = action_dict.get('message')
func = getattr(obj, arg1)
func_name = arg1
break
if func_name:
# with input
if count_parameters_names(func) > 0:
form = factory.get_class_action_form(request, obj.model, action_dict, func)
# it is not @action
else:
# @subset or @meta
for subset in CACHE['SUBSETS'][model]:
if arg1 == subset['name']:
func_name = arg1
break
if func_name:
func = getattr(obj, func_name)
# it is not @subset
else:
# @meta
for method in CACHE['MANAGER_METHODS'].get(model, []):
if method['function'] == arg1:
func_name = arg1
func = getattr(obj, func_name)
break
# list or save
else:
if request.method.lower() == 'get':
obj = model.objects.all(user)
func_name = 'all'
else:
form = factory.get_register_form(request, model())
# list or action
if func_name:
if form:
if form.is_valid():
params = []
func = getattr(obj, func_name)
for param in get_parameters_names(func, include_annotated=True):
if param in form.cleaned_data:
params.append(form.cleaned_data[param])
else:
params.append(get_role_value_for_action(func, request.user, param))
try:
result = func(*params)
if hasattr(result, 'all'):
result = result[page*10:(page*10)+10]
except ValidationError as e:
message = None
form.add_error(None, e.message)
else:
errors = form.errors
elif obj:
try:
func = getattr(obj, func_name)
args = get_role_values_for_condition(func, request.user)
result = func(*args)
if hasattr(result, 'all'):
result = result[page*10:(page*10)+10]
except ValidationError as e:
errors = {'__all__': e.message}
message = None
return HttpResponse(
json_serialize(result, request.GET, errors=errors, message=message, exception=None)
)
# add or edit
elif form:
if form.is_valid():
result = form.save()
message = _('Action successfully performed.')
else:
errors = form.errors
return HttpResponse(
json_serialize(result, request.GET, errors=errors, message=message, exception=None)
)
# get or delete
else:
return HttpResponse(
json_serialize(result, request.GET, errors=errors, message=message, exception=None)
)
else:
user = auth.authenticate(username=request.POST['username'], password=request.POST['password'])
if user is not None:
return HttpResponse(
json_serialize(result, request.GET, errors=[], message=_('Action successfully performed.'), exception=None, result=dict(token=user.token, id=user.id))
)
else:
return HttpResponseForbidden()
def _register(self, action):
model = find_model_by_add_label(action)
if model:
verbose_name = get_metadata(model, 'verbose_name')
button_label = get_metadata(model, 'add_label')
func_name = slugify(button_label).replace('-', '_')
else:
verbose_name = action.replace(_(u'Register'), u'').strip()
model = find_model_by_verbose_name(verbose_name)
button_label = _(u'Register')
func_name = u'cadastrar_%s' % model.__name__.lower()
# set the attributes of the usecase
self.name = action
self.description = '%s %s %s' % (_(u'Add new records of'),
verbose_name.lower(),
_(u'in the system'))
self.business_rules = utils.extract_exception_messages(model.save)
self.post_condition = _(
u'The record will be successfully registered in the system')
required_data = []
for field in get_metadata(model, 'get_fields'):
if isinstance(field, model_fields.ForeignKey):
if not isinstance(field, model_fields.OneToOneField):
if not isinstance(field, model_fields.OneToManyField):
required_data.append(field.verbose_name.lower())
if required_data:
pre_condition = _(
u'The following information must have been previouly registered in the system: '
)
self.pre_conditions.append(
'%s %s' % (pre_condition, u', '.join(required_data)))
for meta_data in ('can_admin', 'can_admin_by_role',
'can_admin_by_unit', 'can_admin_by_organization',
'can_add', 'can_add_by_role', 'can_add_by_unit',
'can_add_by_organization'):
for actor in get_metadata(model, meta_data, iterable=True):
if actor:
self.actors.append(actor)
if not self.actors:
self.actors.append(_(u'Superuser'))
# register the interactions and testing code
func_signature = u'%s(self)' % func_name
self._test_flow_code.append(u'\t\t\t# %s' % action)
self._test_flow_code.append(u'\t\t\tself.%s()' % func_name)
self._test_function_code.append('\tdef %s:' % func_signature)
self._find(model)
self._test_function_code.append(u"\t\tself.click_button(u'%s')" %
button_label)
a = _(u'The user clicks the button')
b = _(u'on the right-side of the action bar')
self._interactions.append(u'%s "%s" %s' % (a, button_label, b))
form = factory.get_register_form(self._mocked_request(), model())
self._fill_out(form)
interaction = _(u'The user clicks the button')
self._interactions.append(u'%s "%s"' % (interaction, button_label))
self._test_function_code.append(u"\t\tself.click_button(u'%s')" %
button_label)
self._test_function_code.append(u"\t\tself.click_icon(u'%s')" %
u'Principal')