def phrases(request):
PhraseForm = modelform_factory(Phrase)
if request.method == 'POST':
"""
form = PhraseForm(request.POST)
form.save()
"""
phrases = request.POST['phrase'].encode('ascii','ignore').split('\r\n')
for p in phrases:
if p:
p = p.decode('utf-8')
p = p.strip()
p = p.replace('-',' ')
p = p.lower()
if ' ' in p:
if Phrase.objects.filter(phrase=p).count() == 0:
print('save: ' + p)
newphrase = Phrase()
newphrase.phrase = p
newphrase.save()
form = modelform_factory(Phrase,
widgets={ 'phrase' : forms.Textarea(attrs={'class': 'form-control'})})
phrases = Phrase.objects.all()
context = { 'phrases' : phrases, 'form' : form }
return render(request, 'operations/phrases.html',context)
def add_or_edit(request, app_label, model_class, id=None):
context = {}
Model = get_model(app_label, model_class, False)
context['ModelClass'] = Model
context['app_label'] = app_label
fields = get_fields(Model, True)
BaseModelForm = BaseForm
if model_class == 'user':
BaseModelForm = UserForm
ModelForm = modelform_factory(Model, form=BaseModelForm)
else:
ModelForm = modelform_factory(Model, fields=tuple(fields), form=BaseModelForm)
if id:
instance = get_object_or_404(Model, id=id)
else:
instance = None
if request.method == 'GET':
defaults = {}
for k, v in request.GET.items():
if isinstance(v, list):
defaults[k] = v[0]
else:
defaults[k] = v
context['formset'] = ModelForm(instance=instance, initial=defaults)
else:
formset = ModelForm(request.POST, instance=instance)
if formset.is_valid():
instances = formset.save()
return redirect('nexus_list', app_label=app_label, model_class=model_class)
transaction.rollback()
context['formset'] = formset
return render(request, 'nexus/add.html', context)
def get_form_class(self):
"""
Returns the form class to use in this view.
"""
if 'form_cls' in self.kwargs:
try:
form_class = self._get_class_from_string(
self.kwargs['form_cls'])
except ImportError:
# use standard form instead of raising exception
pass
else:
return model_forms.modelform_factory(self.model, exclude=[],
form=form_class)
if self.form_class:
return self.form_class
else:
if self.model is not None:
# If a model has been explicitly provided, use it
model = self.model
elif hasattr(self, 'object') and self.object is not None:
# If this view is operating on a single object, use
# the class of that object
model = self.object.__class__
return model_forms.modelform_factory(model, exclude=[],
form=SelfHandlingModelForm)
def get_form_class(self):
"""
Returns the form class to use in this view.
"""
if self.form_class:
return self.form_class
elif self.related_model:
widgets = autocomplete_light.get_widgets_dict(self.related_model)
return modelform_factory(
self.related_model,
widgets=widgets,
form=self.form,
fields=self.fields,
exclude=self.exclude,
formfield_callback=self.get_formfield_callback(),
)
elif self.model:
widgets = autocomplete_light.get_widgets_dict(self.model)
return modelform_factory(
self.model,
widgets=widgets,
form=self.form,
fields=self.fields,
exclude=self.exclude,
formfield_callback=self.get_formfield_callback(),
)
msg = "'%s' must either define 'form_class' or define 'model' or override 'get_form_class()'"
raise ImproperlyConfigured(msg % self.__class__.__name__)
def get_form_class(self, obj):
# check if the block has a class-level attribute that
# defines a specific form class to be used
get_form_class = getattr(obj.__class__, 'get_form_class', None)
if not get_form_class:
return modelform_factory(obj.__class__)
return modelform_factory(obj.__class__, form=get_form_class())
def get_step_form(self, step=None):
if step is None:
step = self.steps.current
attrs = self.get_form_list()[step]
if type(attrs) in (list, tuple):
return modelform_factory(
self.model, form=forms.ModelForm, fields=attrs, formfield_callback=self.admin_view.formfield_for_dbfield
)
elif type(attrs) is dict:
if attrs.get("fields", None):
return modelform_factory(
self.model,
form=forms.ModelForm,
fields=attrs["fields"],
formfield_callback=self.admin_view.formfield_for_dbfield,
)
if attrs.get("callback", None):
callback = attrs["callback"]
if callable(callback):
return callback(self)
elif hasattr(self.admin_view, str(callback)):
return getattr(self.admin_view, str(callback))(self)
elif isinstance(attrs, forms.BaseForm):
return attrs
return None
def get_model_form(self, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(self.get_readonly_fields())
if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude:
# Take the custom ModelForm's Meta.exclude into account only if the
# ModelAdmin doesn't define its own.
exclude.extend(self.form._meta.exclude)
# if exclude is an empty list we pass None to be consistant with the
# default on modelform_factory
exclude = exclude or None
defaults = {
"form": self.form,
"fields": self.fields and list(self.fields) or None,
"exclude": exclude,
"formfield_callback": self.formfield_for_dbfield,
}
defaults.update(kwargs)
if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
defaults['fields'] = forms.ALL_FIELDS
return modelform_factory(self.model, **defaults)
try:
return modelform_factory(self.model, **defaults)
except FieldError as e:
raise FieldError('%s. Check fields/fieldsets/exclude attributes of class %s.'
% (e, self.__class__.__name__))
def edita( request, pk = None ):
(user, l4) = tools.getImpersonateUser(request)
todo = ToDo.objects.get(pk = pk) if pk and user.todo_set.filter( pk = pk ).exists() else None
if request.method == 'POST':
formF = modelform_factory( ToDo, fields = ( 'data', 'tasca' , 'informacio_adicional', 'estat' , 'prioritat', 'enllac' ))
form = formF( request.POST )
if not form.instance.pk:
form.instance.propietari = user
if form.is_valid( ):
form.save()
return HttpResponseRedirect( '/todo/list/' )
else:
form = modelform_factory( ToDo, fields = ( 'data','tasca' , 'informacio_adicional', 'estat' , 'prioritat', 'enllac' ))
if todo: form = form( instance = todo )
form.base_fields['data'].widget = forms.DateTimeInput(attrs={'class':'DateTimeAnyTime'} )
#form = formF( )
return render(
request,
"form.html",
{"form": form,
"head": 'Edita tasca',
},
)
def get_common_data(self, request):
if self.what not in ("newspaper", "internet", "television", "billboard"):
raise Http404()
data = {}
form1_klass = None
form2_klass = None
valid = False
ins = None
if self.what == "newspaper":
form1_klass = Newspaper
ins = Newspaper.objects.get(id=self.idx)
elif self.what == "section":
form1_klass = Section
ins = Section.objects.get(id=self.idx)
elif self.what == "television":
form1_klass = Television
ins = Television.objects.get(id=self.idx)
elif self.what == "program":
form1_klass = Program
ins = Program.objects.get(id=self.idx)
elif self.what == "billboard":
form1_klass = Billboard
ins = Billboard.objects.get(id=self.idx)
elif self.what == "internet":
form1_klass = Website
ins = Website.objects.get(id=self.idx)
Form1 = modelform_factory(form1_klass, formfield_callback=self.formfield_call_back)
newsf = Form1(request.POST or None, instance=ins)
if form2_klass is not None:
Form2 = modelform_factory(form2_klass, formfield_callback=self.formfield_call_back)
secf = Form2(request.POST or None)
if "form1" in request.POST:
if newsf.is_valid():
newsf.save()
valid = True
elif "form2" in request.POST:
if secf.is_valid():
secf.save()
valid = True
if valid:
newsf = Form1()
if valid and form2_klass is not None:
secf = Form2()
if form2_klass is not None:
data['form2'] = secf
data['form1'] = newsf
return data
def _init_forms(self):
if 'post' in self.allowed_methods and self.add_form_class is None:
self.add_form_class = modelform_factory(self.model,
fields=self.fields)
if 'put' in self.allowed_methods and self.edit_form_class is None:
self.edit_form_class = modelform_factory(self.model,
fields=self.fields)
def get_form_class(self):
if self.batch is None:
form = modelform_factory(Comment, fields=('batch', 'viewpoint'), widgets={'batch': TextInput()})
else:
form = modelform_factory(Comment, fields=('viewpoint',))
print(dir(form))
form.base_fields['viewpoint'].widget.attrs['cols'] = 33
form.base_fields['viewpoint'].widget.attrs['rows'] = 6
return form
def get_form_class(self):
model = self.object.__class__
get_form_class = getattr(model, 'get_form_class')
if get_form_class and get_form_class():
return modelform_factory(model, form=get_form_class())
form_class = getattr(
forms, "%sForm" % model.__name__, forms.BlockForm)
return modelform_factory(model, form=form_class)
def project_sheet_show(request, slug, add_media=False):
"""
Display a project sheet
"""
language_code = translation.get_language()
project_translation = get_object_or_404(I4pProjectTranslation,
slug=slug,
language_code=language_code)
# Info
project_info_form = I4pProjectInfoForm(request.POST or None,
instance=project_translation.project)
if request.method == 'POST' and project_info_form.is_valid():
project_info_form.save()
project_themes_form = I4pProjectThemesForm(instance=project_translation)
project_objectives_form = I4pProjectObjectivesForm(instance=project_translation.project, prefix="objectives-form")
project_member_form = ProjectMemberForm()
#project_member_formset = ProjectMemberFormSet(queryset=project_translation.project.detailed_members.all())
project_location_form = I4pProjectLocationForm(instance=project_translation.project.location)
reference_formset = ProjectReferenceFormSet(queryset=project_translation.project.references.all())
project_status_choices = OrderedDict((k, unicode(v))
for k, v in I4pProject.STATUS_CHOICES)
project_status_choices['selected'] = project_translation.project.status
context = {'project': project_translation.project,
'project_translation': project_translation,
'project_themes_form': project_themes_form,
'project_objectives_form': project_objectives_form,
'reference_formset' : reference_formset,
'project_info_form': project_info_form,
'project_location_form': project_location_form,
'project_member_form': project_member_form,
'project_status_choices': simplejson.dumps(project_status_choices),
#'project_member_formset': project_member_formset,
'project_tab' : True}
if add_media:
ProjectPictureForm = modelform_factory(ProjectPicture, fields=('original_image',
'desc',
'license',
'author',
'source'))
ProjectVideoForm = modelform_factory(ProjectVideo, fields=('video_url',))
context.update({'picture_form' : ProjectPictureForm(),
'video_form' : ProjectVideoForm()})
return render_to_response(template_name='project_sheet/project_sheet.html',
dictionary=context,
context_instance=RequestContext(request)
)
def dashboard(request):
""" The main homepage for managing goals """
lyfeuser = get_object_or_404(LyfeUser, pk=request.user.username)
goalitems = make_goalitems(lyfeuser, list(GoalGroup.objects.filter(ownerid=lyfeuser.pk)))
activegoalitems = goalitems[0]
inactivegoalitems = goalitems[1]
# friend requests
friend_requests = list(Friend.objects.filter(recipient_id=lyfeuser, is_approved=False))
# friends
friends = list(Friend.objects.filter(requester_id=lyfeuser, is_approved=True))
# groups and membership requests
memberships = Membership.objects.filter(user_id=lyfeuser, accepted=True)
groups = []
membership_requests = []
for membership in memberships:
groups.append(membership.group_id)
# if the user owns groups, show membership requests
if membership.group_id.creator_id == lyfeuser:
membership_requests.extend(Membership.objects.filter(group_id=membership.group_id, accepted=False))
# newsfeed
friendIDs = []
friendIDs.append(lyfeuser.pk) # you can see your own updates
for friend in friends:
friendIDs.append(friend.recipient_id)
updates = list(Update.objects.filter(user_id_id__in=friendIDs).order_by('timestamp').reverse()[:15])
# replace this awkward comment correction with notification model in the future
for update in updates:
if not update.public and update.user_id != lyfeuser:
updates.remove(update)
newsfeed = make_newsfeed(updates, lyfeuser, private=True, friends=True, gids=groups)
# update form
updateform = modelform_factory(Update, fields=('content', 'completion'), widgets={'content': forms.Textarea(attrs={'placeholder' : 'REQUIRED: Description. Can only post an update once every 30 minutes.'})})
# goal category form
goal_groupform = modelform_factory(GoalGroup, fields=('name', 'sharee'))
goal_formset = inlineformset_factory(GoalGroup, Goal, extra=1, fields=('name', 'difficulty'), can_delete=False, labels={'name' : 'Initial goal'})
# goal form
actionitem_form = modelform_factory(Goal, fields=('name', 'difficulty'))
# comment form
commentForm = modelform_factory(Comment, fields=('content',), widgets={'content': forms.TextInput(attrs={'placeholder' : 'Add comment'})})
# group form
groupForm = modelform_factory(Group, fields=('name', 'description', 'logo'))
return render_to_response('core/dashboard.html',
{ 'lyfeuser' : lyfeuser, 'activegoalitems' : activegoalitems, 'inactivegoalitems' : inactivegoalitems, 'friend_requests' : friend_requests, 'membership_requests' : membership_requests, 'friends' : friends, 'groups' : groups, 'updateform' : updateform, 'newsfeed' : newsfeed, 'goal_groupform' : goal_groupform, 'goal_formset' : goal_formset, 'actionitem_form' : actionitem_form, 'commentForm' : commentForm, 'groupForm' : groupForm},
context_instance=RequestContext(request))
def test_save_modelform(self):
mform1 = modelform_factory(model=Example, fields=['a', 'b'])({'a': 'a', 'b': 2})
mform2 = modelform_factory(model=Example2, exclude=['d'])({'c': 'c'})
instances = [mform1, mform2]
form = CompositeModelForm(form_instances=instances)
form.save()
self.assertEquals(Example.objects.filter(a='a', b=2).count(), 1)
self.assertEquals(Example2.objects.filter(c='c').count(), 1)
def test_save_rollback(self):
mform1 = modelform_factory(model=Example, fields=['a', 'b'])({'a': 'a'})
mform2 = modelform_factory(model=Example2, exclude=['d'])({'c': 'c'})
instances = [mform1, mform2]
form = CompositeModelForm(form_instances=instances)
self.assertRaises(ValueError, lambda: form.save())
self.assertEquals(Example.objects.count(), 0)
self.assertEquals(Example2.objects.count(), 0)
def __init__(self, *args, **kwargs):
super(DjangoModelResource, self).__init__(*args, **kwargs)
# Construct a default form if we don't have one already.
if not self.form:
if self.fields:
# Limit it to the specified fields, if given.
self.form = modelform_factory(self.model, fields=self.fields)
else:
self.form = modelform_factory(self.model)
def test_init_modelforms(self):
mform1 = modelform_factory(model=Example, fields=['a', 'b'])()
mform2 = modelform_factory(model=Example2, exclude=['d'])()
instances = [mform1, Form1()]
self.assertRaises(ValueError, lambda: CompositeModelForm(form_instances=instances))
instances = [mform1, mform2]
form = CompositeModelForm(form_instances=instances)
self.assertIsInstance(form, CompositeModelForm)
self.assertTrue(hasattr(form, 'save'))
def get_context_data(self, **kwargs):
context = super(ProjectAddMediaView, self).get_context_data(**kwargs)
ProjectPictureForm = modelform_factory(
ProjectPicture, fields=("original_image", "desc", "license", "author", "source")
)
ProjectVideoForm = modelform_factory(ProjectVideo, fields=("video_url",))
context.update({"picture_form": ProjectPictureForm(), "video_form": ProjectVideoForm()})
return context
def __init__(self, *args, **kwargs):
super(DjangoModelResource, self).__init__(*args, **kwargs)
""" create a translator object, so we have the regex' cached """
self.translator = translator()
# Construct a default form if we don't have one already.
if not self.form:
if self.fields:
# Limit it to the specified fields, if given.
self.form = modelform_factory(self.model, fields=self.fields)
else:
self.form = modelform_factory(self.model)
def test_factory_with_widget_argument(self):
""" Regression for #15315: modelform_factory should accept widgets
argument
"""
widget = forms.Textarea()
# Without a widget should not set the widget to textarea
Form = modelform_factory(Person, fields="__all__")
self.assertNotEqual(Form.base_fields['name'].widget.__class__, forms.Textarea)
# With a widget should not set the widget to textarea
Form = modelform_factory(Person, fields="__all__", widgets={'name': widget})
self.assertEqual(Form.base_fields['name'].widget.__class__, forms.Textarea)
def post(self, request):
classname = request.POST["classname"]
if classname == "manufacturer":
form = modelform_factory(Manufacturer, exclude=(), form=AddForm)()
elif classname == "devicetype":
form = modelform_factory(Type, exclude=(), form=AddForm)()
elif classname == "room":
form = modelform_factory(Room, exclude=(), form=AddForm)()
elif classname == "group":
form = modelform_factory(Devicegroup, exclude=(), form=AddForm)()
else:
return HttpResponse("")
return HttpResponse(render_to_string('snippets/formfields.html', {"form": form}))
def get_form(self):
"""Creates and returns a form on the fly from the model using
`modelform_factory`.
The returned form is instantiated with `self.obj`.
"""
if self.kwargs.get('form'): # Custom form
try:
form = import_class(self.kwargs.get('form'))
except ImportError: # TODO: warning sent to logger or something ?
form = modelform_factory(self.model)
else: # Generic form
form = modelform_factory(self.model)
return form(data=get_dict_from_obj(self.obj), instance=self.obj)
def get_form_class(self):
if self.object:
# Existing task edit page
form_class = modelform_factory(Task, widgets={'organization': HiddenInput})
else:
# New task page
form_class = modelform_factory(Task, exclude=['status'])
# Limit assigned user choices to active experts.
_experts = User.objects.filter(groups__name__in=UserProfile.expert_groups, is_active=True)
form_class.base_fields['user'].queryset = _experts.distinct()
# Limit organizations choices to this monitoring.
form_class.base_fields['organization'].queryset = self.monitoring.organization_set.all()
return form_class
def get_context_data(self, **kwargs):
context = super(ProjectAddMediaView, self).get_context_data(**kwargs)
ProjectPictureForm = modelform_factory(ProjectPicture, fields=('original_image',
'desc',
'license',
'author',
'source'))
ProjectVideoForm = modelform_factory(ProjectVideo, fields=('video_url',))
context.update({'picture_form' : ProjectPictureForm(),
'video_form' : ProjectVideoForm()})
return context
def view_thread(request, thread_id):
request.session['current_page'] = request.path
template = loader.get_template('fora/fora.html')
fora = Forum.objects.all()
if thread_id:
active_thread = get_object_or_404(ForumThread, id=thread_id)
else:
threads = ForumThread.objects.filter(hidden=False).order_by(
'-time_created'
)
if threads.exists():
active_thread = threads[0]
else:
active_thread = None
reply_form = modelform_factory(
ForumMessage,
exclude=(
'forum_thread',
'in_reply_to',
'creator',
'time_created',
'last_modified',
'score',
'hidden'
)
)
context_dict = {
'fora': fora,
'active_thread': active_thread,
'form': reply_form(),
}
context_dict.update(get_common_context(request))
context_dict.update(get_permissions(request.user))
return HttpResponse(template.render(context_dict, request))
def create_forum(request):
if not Permissions.can_create_forum(request.user):
raise PermissionDenied()
NewForumForm = modelform_factory(Forum)
form = NewForumForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
request.session['success_message'] = 'Forum successfully created'
return get_previous_page(request, alternate='fora:index')
else:
request.session['error_message'] = messages.GENERIC_SUBMIT_ERROR
template = loader.get_template('generic_form.html')
context_dict = {
'form': form,
'has_files': False,
'submit_name': 'Create new forum',
'form_title': 'Create new forum',
'help_text': ('A new forum should be organized around a topic or a '
'style of post.'),
'base': 'fora/base_fora.html',
'back_button': {
'link': reverse('fora:index'),
'text': 'Back to fora'
},
}
context_dict.update(get_permissions(request.user))
context_dict.update(get_common_context(request))
return HttpResponse(template.render(context_dict, request))
def post(self, request, object_id):
self.org_obj = self.get_object(unquote(object_id))
if not self.has_change_permission(self.org_obj):
raise PermissionDenied
if self.org_obj is None:
raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % \
{'name': force_unicode(self.opts.verbose_name), 'key': escape(object_id)})
pk = getattr(self.org_obj, self.org_obj._meta.pk.attname)
model_fields = [str(pk) + '-' + f.name for f in self.opts.fields]
fields = [f[len(str(pk)) + 1:] for f in request.POST.keys() if f in model_fields]
defaults = {
"form": forms.ModelForm,
"fields": fields,
"formfield_callback": self.formfield_for_dbfield,
}
form_class = modelform_factory(self.model, **defaults)
form = form_class(instance=self.org_obj, data=request.POST, files=request.FILES)
form.prefix = str(pk)
result = {}
if form.is_valid():
form.save(commit=True)
result['result'] = 'success'
result['new_data'] = form.cleaned_data
result['new_html'] = dict([(f, self.get_new_field_html(f)) for f in fields])
else:
result['result'] = 'error'
result['errors'] = JsonErrorDict(form.errors, form).as_json()
return self.render_response(result)
def test_invalid_syntax(self):
"""
Ensures that invalid template syntax will result in validation errors
when saving a ModelForm of an EmailTemplate.
"""
data = dict(
name='cost',
subject='Hi there!{{ }}',
content='Welcome {{ name|titl }} to the site.',
html_content='{% block content %}<h1>Welcome to the site</h1>'
)
EmailTemplateForm = modelform_factory(EmailTemplate,
exclude=['template'])
form = EmailTemplateForm(data)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['default_template'], [u'This field is required.'])
self.assertEqual(form.errors['content'], [u"Invalid filter: 'titl'"])
self.assertIn(form.errors['html_content'],
[[u'Unclosed tags: endblock '],
[u"Unclosed tag on line 1: 'block'. Looking for one of: endblock."]])
self.assertIn(form.errors['subject'],
[[u'Empty variable tag'], [u'Empty variable tag on line 1']])
def get_image_form():
return modelform_factory(
get_image_model(),
# set the 'file' widget to a FileInput rather than the default ClearableFileInput
# so that when editing, we don't get the 'currently: ...' banner which is
# a bit pointless here
widgets={'file': forms.FileInput()})
class UpdateSprintView(ActiveProjectRequiredMixin, LoginRequiredMixin,
GlobalPermissionRequiredMixin, generic.UpdateView):
"""
Vista para actualizar los datos del Sprint y del UserStory que son el desarrollador, la fase y el Sprint
"""
model = Sprint
permission_required = 'project.edit_sprint'
template_name = 'project/sprint/sprint_form.html'
form_class = modelform_factory(Sprint,
form=AddSprintBaseForm,
widgets={
'inicio': SelectDateWidget,
'proyecto': HiddenInput
},
fields={'nombre', 'inicio', 'proyecto'})
UserStoryFormset = formset_factory(AddToSprintForm,
formset=AddToSprintFormset,
can_delete=True,
extra=1)
formset = None
def get_proyecto(self):
return self.get_object().proyecto
def get_permission_object(self):
"""
permiso para add, edit o delete
:return: los permisos
"""
return self.get_object().proyecto
def get_success_url(self):
"""
:return:la url de redireccion a la vista de los detalles del sprint modificado.
"""
return reverse('project:sprint_detail', kwargs={'pk': self.object.id})
def __filtrar_formset__(self, formset):
for userformset in formset.forms:
userformset.fields['desarrollador'].queryset = User.objects.filter(
miembroequipo__proyecto=self.object.proyecto)
userformset.fields['flujo'].queryset = Flujo.objects.filter(
proyecto=self.object.proyecto)
userformset.fields[
'userStory'].queryset = UserStory.objects.filter(
proyecto=self.object.proyecto)
def get_context_data(self, **kwargs):
"""
Especifica los datos de contexto a pasar al template
:param kwargs: Diccionario con parametros con nombres clave
:return: los datos de contexto
"""
context = super(UpdateSprintView, self).get_context_data(**kwargs)
current_us = self.get_object().userstory_set.all()
formset = self.UserStoryFormset(
self.request.POST if self.request.method == 'POST' else None,
initial=[{
'userStory': us,
'flujo': us.fase.flujo,
'desarrollador': us.desarrollador
} for us in current_us])
self.__filtrar_formset__(formset)
context['current_action'] = 'Editar'
context['formset'] = formset
return context
def form_valid(self, form):
"""
Guarda el desarrollador, fase y sprint asociado al un projecto dentro de un User Story
:param form: formulario del sprint
:return: vuelve a la pagina de detalle del sprint
"""
self.object = form.save(commit=False)
self.object.fin = self.object.inicio + datetime.timedelta(
days=self.object.proyecto.duracion_sprint)
self.object.save()
formsetb = self.UserStoryFormset(self.request.POST)
if formsetb.is_valid():
proccessed_forms = []
for subform in formsetb:
if subform.has_changed(
) and 'userStory' in subform.cleaned_data:
new_userStory = subform.cleaned_data['userStory']
if subform in formsetb.deleted_forms and not new_userStory in proccessed_forms:
# desaciamos los user story que se eliminaron del form
new_userStory.desarrollador = None
new_userStory.sprint = None
new_userStory.fase = None
else:
new_flujo = subform.cleaned_data['flujo']
self.flujo = new_flujo
new_desarrollador = subform.cleaned_data[
'desarrollador']
if new_userStory.estado != 3 and new_userStory.estado != 4: #si el user story no ha finalizado
new_userStory.desarrollador = new_desarrollador
new_userStory.sprint = self.object
new_userStory.fase = self.flujo.fase.first()
new_userStory.estado = 1
new_userStory.estado_fase = 0
new_userStory.save()
proccessed_forms.append(new_userStory)
return HttpResponseRedirect(self.get_success_url())
self.__filtrar_formset__(formsetb)
return render(self.request,
self.get_template_names(), {
'form': form,
'formset': formsetb
},
context_instance=RequestContext(self.request))
def __init__(self, *args, **kwargs):
super(RequestForm, self).__init__(*args, **kwargs)
self.fields['role'].widget.choices = [
(role.id, unicode(role))
for role in Role.objects.filter(user__isnull=True)
]
def clean_role(self):
try:
return Role.objects.get(pk=self.cleaned_data['role'],
user__isnull=True)
except Role.DoesNotExist:
raise forms.ValidationError('Неизвестная роль')
def save(self, user):
self.cleaned_data['role'].user = user
self.cleaned_data['role'].save()
user.role = self.cleaned_data['role']
user.save()
RoleForm = modelform_factory(Role, exclude=('user', ))
ConnectionFormSet = forms.inlineformset_factory(Role,
RoleConnection,
fk_name='role',
exclude=('is_locked', ),
extra=1)
def test_form_field_order(self):
form = modelform_factory(TestModel, fields="__all__")()
self.assertEqual(list(form.fields),
["name_en", "name_de", "other_en", "other_de"])
def get_form_class(self):
return modelform_factory(self.model, form=BaseUserForm, fields=self.fields)
def get_inline_model_form(self):
""" Build model form for inline model. """
return modelform_factory(model=self.pretty_csv_inline['inline'].model,
fields=self.pretty_csv_inline['fields'])
from django.conf import settings
from django import forms
from django.forms.models import modelform_factory
from django.forms import ValidationError
from django.utils.translation import ugettext_lazy as _
from mezzanine.core.forms import TinyMceWidget
from mezzanine.generic.forms import ThreadedCommentForm
from drum.links.models import Link
BaseLinkForm = modelform_factory(Link, fields=["title", "link", "content"], widgets={"content": TinyMceWidget})
class LinkForm(BaseLinkForm):
def clean(self):
link = self.cleaned_data.get("link", None)
content = self.cleaned_data.get("content", None)
if not link and not content:
raise ValidationError("Either a link or description is required")
return self.cleaned_data
class ArtnewsCommentForm(ThreadedCommentForm):
name = forms.CharField(label=_("Name"), help_text=_("required"),
max_length=50, widget=forms.HiddenInput)
email = forms.EmailField(label=_("Email"),
help_text=_("required (not published)"), widget=forms.HiddenInput)
Post,
Article,
Concrete,
NullTestModel,
DefaultTestModel,
NullDefaultTestModel,
)
from django.forms.models import modelform_factory
ArticleForm = modelform_factory(
Article,
fields=[
"normal_field",
"normal_field_markup_type",
"markup_choices_field",
"markup_choices_field_markup_type",
"default_field",
"default_field_markup_type",
"markdown_field",
],
)
class MarkupFieldTestCase(TestCase):
def setUp(self):
self.xss_str = "<script>alert('xss');</script>"
self.mp = Post(
title="example markdown post",
body="**markdown**",
body_markup_type="markdown",
)
def get_form(self, model, *args, **kwargs):
Form = modelform_factory(
model, exclude=['owner', 'order', 'created', 'updated'])
return Form(*args, **kwargs)
class AddSprintView(ActiveProjectRequiredMixin, LoginRequiredMixin,
CreateViewPermissionRequiredMixin, generic.CreateView):
"""
Vista para agregar un Sprint en el sistema y añadir este sprint, un desarrollador y una fase al user Story
"""
#TODO Mostrar como initial data del formset los US que quedaron del sprint anterior
model = Sprint
template_name = 'project/sprint/sprint_form.html'
permission_required = 'project.create_sprint'
form_class = modelform_factory(Sprint,
form=AddSprintBaseForm,
widgets={
'inicio': SelectDateWidget,
'proyecto': HiddenInput
},
fields={'nombre', 'inicio', 'proyecto'})
formset = formset_factory(AddToSprintForm,
formset=AddToSprintFormset,
extra=1)
proyecto = None
def get_proyecto(self):
return get_object_or_404(Proyecto, id=self.kwargs['project_pk'])
def get_initial(self):
"""
Datos iniciales para el formulario
:return: diccionario de datos
"""
initial = {'proyecto': self.get_proyecto()}
return initial
def get_permission_object(self):
"""
Obtener el permiso de un objeto
:param: self
:return: retorna el objeto proyecto donde se comprueba el permiso
"""
return get_object_or_404(Proyecto, id=self.kwargs['project_pk'])
def get_success_url(self):
"""
:return:la url de redireccion a la vista de los detalles del sprint agregado.
"""
return reverse('project:sprint_detail', kwargs={'pk': self.object.id})
def __filtrar_formset__(self, formset):
for userformset in formset.forms:
userformset.fields['desarrollador'].queryset = User.objects.filter(
miembroequipo__proyecto=self.proyecto)
userformset.fields['flujo'].queryset = Flujo.objects.filter(
proyecto=self.proyecto)
userformset.fields[
'userStory'].queryset = UserStory.objects.filter(
Q(proyecto=self.proyecto),
Q(estado=1) | Q(estado=0))
def get_context_data(self, **kwargs):
"""
Agregar datos al contexto como los desarrolladores del projecto, el flujo y los userStory
:param:**kwargs : argumentos clave
:return: retorna el contexto
"""
context = super(AddSprintView, self).get_context_data(**kwargs)
self.proyecto = self.get_proyecto()
formset = self.formset(self.request.POST if self.request.method ==
'POST' else None)
self.__filtrar_formset__(formset)
context['current_action'] = 'Agregar'
context['formset'] = formset
return context
def form_valid(self, form):
"""
Guarda el desarrollador, fase y sprint asociado al un projecto dentro de un User Story
:param form: formulario del sprint
:return: vuelve a la pagina de detalle del sprint o renderea la pagina marcando los errores para volver a enviar sin errores
"""
self.proyecto = self.get_proyecto()
self.object = form.save(commit=False)
self.object.fin = self.object.inicio + datetime.timedelta(
days=self.proyecto.duracion_sprint)
self.proyecto.estado = 'EP'
self.proyecto.save()
self.object.save()
formsetb = self.formset(self.request.POST)
if formsetb.has_changed():
if formsetb.is_valid():
for subform in formsetb:
new_userStory = subform.cleaned_data['userStory']
new_flujo = subform.cleaned_data['flujo']
self.flujo = new_flujo
new_desarrollador = subform.cleaned_data['desarrollador']
new_userStory.desarrollador = new_desarrollador
new_userStory.sprint = self.object
new_userStory.fase = self.flujo.fase_set.first()
new_userStory.estado_fase = 0
new_userStory.estado = 1 #El User Story pasa a estar en curso por incluirse en el Sprint
new_userStory.save()
return HttpResponseRedirect(self.get_success_url())
else:
return render(self.request,
self.get_template_names(), {
'form': form,
'formset': formsetb
},
context_instance=RequestContext(self.request))
else:
return HttpResponseRedirect(self.get_success_url())
