def register(self, request, **kwargs): """ Register a new user account, which will initially be inactive. It also creates corresponding user profile. """ user = super(ProfileBackend, self).register(request, **kwargs) profile, created = utils.get_profile_model().objects.get_or_create(user=user) # lambda-object to the rescue form = lambda: None form.cleaned_data = kwargs # First name, last name and e-mail address are stored in user object forms_models.construct_instance(form, user) user.save() # Other fields are stored in user profile object forms_models.construct_instance(form, profile) profile.save() user_profile_registered.send(sender=self.__class__, user=user, profile=profile, request=request) return user
def register(self, request, **kwargs): """ Register a new user account, which will initially be inactive. It also creates corresponding user profile. """ user = super(ProfileBackend, self).register(request, **kwargs) profile, created = utils.get_profile_model().objects.get_or_create( user=user) # lambda-object to the rescue form = lambda: None form.cleaned_data = kwargs # First name, last name and e-mail address are stored in user object forms_models.construct_instance(form, user) user.save() # Other fields are stored in user profile object forms_models.construct_instance(form, profile) profile.save() user_profile_registered.send(sender=self.__class__, user=user, profile=profile, request=request) return user
def _post_clean(self): """ Stores translation data into translation instance """ opts = self._meta translation = self.instance._get_translation(get_active(), can_create=True) if opts.exclude is None: exclude = ('id', 'language_code', 'master') else: exclude = list(opts.exclude) + ['id', 'language_code', 'master'] # Update instance translation construct_instance(self, translation, opts.fields, exclude) super(BaseMultilingualModelForm, self)._post_clean()
def _post_clean(self): opts = self._meta # Update the model instance with self.cleaned_data. self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude) exclude = self._get_validation_exclusions() # Foreign Keys being used to represent inline relationships # are excluded from basic field value validation. This is for two # reasons: firstly, the value may not be supplied (#12507; the # case of providing new values to the admin); secondly the # object being referred to may not yet fully exist (#12749). # However, these fields *must* be included in uniqueness checks, # so this can't be part of _get_validation_exclusions(). for f_name, field in self.fields.items(): if isinstance(field, InlineForeignKeyField): exclude.append(f_name) # Clean the model instance's fields. try: if isinstance(self.instance, models.ModelWithRequest): self.instance.clean_fields(request=self.request, exclude=exclude) else: self.instance.clean_fields(exclude=exclude) except ValidationError, e: self._update_errors(e.message_dict)
def post_clean_with_simpler_validation(original_function, self): """ Until https://code.djangoproject.com/ticket/16423#comment:3 is implemented, patch it in ourselves: do the same validation on objects when called from the form, as the object would do on itself. """ opts = self._meta # Update the model instance with self.cleaned_data. # print "construct_instance with password = %s" % self.cleaned_data.get('password') self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude) # print "constructed instance with password = %s" % self.instance.password exclude = self._get_validation_exclusions() # Foreign Keys being used to represent inline relationships # are excluded from basic field value validation. This is for two # reasons: firstly, the value may not be supplied (#12507; the # case of providing new values to the admin); secondly the # object being referred to may not yet fully exist (#12749). # However, these fields *must* be included in uniqueness checks, # so this can't be part of _get_validation_exclusions(). for f_name, field in self.fields.items(): if isinstance(field, InlineForeignKeyField): exclude.append(f_name) from django.core.exceptions import ValidationError # Clean the model instance's fields. try: self.instance.full_clean(exclude) except ValidationError, e: self._update_errors(e.update_error_dict(None))
def save(self, commit=True): if self.instance.pk is None: fail_message = 'created' new = True else: fail_message = 'changed' new = False if self.errors: opts = instance._meta raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) trans_model = self.instance._meta.translations_model language_code = self.cleaned_data.get('language_code', get_language()) if not new: trans = get_cached_translation(self.instance) if not trans or trans.language_code != language_code: try: trans = get_translation(self.instance, language_code) except trans_model.DoesNotExist: trans = trans_model() else: trans = trans_model() trans = construct_instance(self, trans, self._meta.fields) trans.language_code = language_code trans.master = self.instance self.instance = combine(trans, self.Meta.model) super(TranslatableModelForm, self).save(commit=commit) return self.instance
def done(self, form_list, **kwargs): # Save patient patient = Patient() for form in form_list: patient = construct_instance(form, patient) patient.created_by = self.request.user patient.updated_by = self.request.user patient.save() # Save management records for management_record in form_list[1].save(commit=False): management_record.patient = patient management_record.created_by = self.request.user management_record.updated_by = self.request.user management_record.save() # Save outcome records for outcome_record in form_list[2].save(commit=False): outcome_record.patient = patient outcome_record.created_by = self.request.user outcome_record.updated_by = self.request.user outcome_record.save() return render(self.request, 'thanks.html', { "patient": patient })
def _post_clean(self): opts = self._meta exclude = self._get_validation_exclusions() try: self.instance = construct_instance(self, self.instance, opts.fields, exclude) except ValidationError as e: self._update_errors(e) self.instance.problem = self.cleaned_data["problem"] # Foreign Keys being used to represent inline relationships # are excluded from basic field value validation. This is for two # reasons: firstly, the value may not be supplied (#12507; the # case of providing new values to the admin); secondly the # object being referred to may not yet fully exist (#12749). # However, these fields *must* be included in uniqueness checks, # so this can't be part of _get_validation_exclusions(). for name, field in self.fields.items(): if isinstance(field, InlineForeignKeyField): exclude.append(name) try: self.instance.full_clean(exclude=exclude, validate_unique=False) except ValidationError as e: self._update_errors(e) # Validate uniqueness if needed. if self._validate_unique: self.validate_unique()
def save(self, commit=True): ''' Saves the model If will always use the language specified in self.cleaned_data, with the usual None meaning 'call get_language()'. If instance has another language loaded, it gets reloaded with the new language. If no language is specified in self.cleaned_data, assume the instance is preloaded with correct language. ''' assert self.is_valid(), ( 'Method save() must not be called on an invalid ' 'form. Check the result of .is_valid() before ' 'calling save().') # Get the right translation for object and language # It should have been done in _post_clean, but instance may have been # changed since. enforce = 'language_code' in self.cleaned_data language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) # Fill the translated fields with values from the form excludes = list(self._meta.exclude) + ['master', 'language_code'] translation = construct_instance(self, translation, self._meta.fields, excludes) set_cached_translation(self.instance, translation) # Delegate shared fields to super() return super(BaseTranslatableModelForm, self).save(commit=commit)
def save(self, commit=True): if self.instance.pk is None: fail_message = 'created' new = True else: fail_message = 'changed' new = False if self.errors: opts = self.instance._meta raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) trans_model = self.instance._meta.translations_model language_code = self.cleaned_data.get('language_code', get_language()) if not new: trans = get_cached_translation(self.instance) if not trans or trans.language_code != language_code: try: trans = get_translation(self.instance, language_code) except trans_model.DoesNotExist: trans = trans_model() else: trans = trans_model() trans = construct_instance(self, trans, self._meta.fields) trans.language_code = language_code trans.master = self.instance self.instance = combine(trans, self.Meta.model) super(TranslatableModelForm, self).save(commit=commit) return self.instance
def form_valid(self, form): form.instance.operator = self.request.user if 'onidc' not in form.cleaned_data: form.instance.onidc = self.request.user.onidc d1 = form.initial message = json.dumps(form.changed_data) response = super(EditModelView, self).form_valid(form) d2 = model_to_dict(construct_instance(form, self.object)) diffs = diff_dict(make_dict(d1), make_dict(d2)) content = json.dumps(diffs) log_action(user_id=self.request.user.pk, content_type_id=get_content_type_for_model( self.object, True).pk, object_id=self.object.pk, action_flag="修改", message=message, content=content) # if self.model_name == 'online': # verify = Thread(target=device_post_save, args=(self.object.pk,)) # verify.start() if self.request.is_ajax(): data = { 'message': "Successfully submitted form data.", 'data': form.cleaned_data } return JsonResponse(data) else: return response
def done(self, form_list, **kwargs): # Save patient patient = Patient() for form in form_list: patient = construct_instance(form, patient) patient.created_by = self.request.user patient.updated_by = self.request.user patient.save() # Save management records for management_record in form_list[1].save(commit=False): management_record.patient = patient management_record.created_by = self.request.user management_record.updated_by = self.request.user management_record.save() # Save outcome records for outcome_record in form_list[2].save(commit=False): outcome_record.patient = patient outcome_record.created_by = self.request.user outcome_record.updated_by = self.request.user outcome_record.save() return render(self.request, 'thanks.html', {"patient": patient})
def process_form_data(form_list): form_data = [form.cleaned_data for form in form_list] new = Person() for form in form_list: new = construct_instance(form, new, form._meta.fields, form._meta.exclude) new.save() return new.id
def _post_clean(self): # TODO: find a way to not copy-paste and override private method... # the only we change is excluding pointer-fields from validation opts = self._meta exclude = self._get_validation_exclusions() + [ f.name for f in self._pointer_fields ] # Foreign Keys being used to represent inline relationships # are excluded from basic field value validation. This is for two # reasons: firstly, the value may not be supplied (#12507; the # case of providing new values to the admin); secondly the # object being referred to may not yet fully exist (#12749). # However, these fields *must* be included in uniqueness checks, # so this can't be part of _get_validation_exclusions(). for name, field in self.fields.items(): if isinstance(field, InlineForeignKeyField): exclude.append(name) try: construct_excludes = opts.exclude + exclude if opts.exclude else exclude self.instance = construct_instance(self, self.instance, opts.fields, construct_excludes) except ValidationError as e: self._update_errors(e) try: self.instance.full_clean(exclude=exclude, validate_unique=False) except ValidationError as e: self._update_errors(e) # Validate uniqueness if needed. if self._validate_unique: self.validate_unique()
def save(self, commit=True): ''' Saves the model If will always use the language specified in self.cleaned_data, with the usual None meaning 'call get_language()'. If instance has another language loaded, it gets reloaded with the new language. If no language is specified in self.cleaned_data, assume the instance is preloaded with correct language. ''' assert self.is_valid(), ('Method save() must not be called on an invalid ' 'form. Check the result of .is_valid() before ' 'calling save().') # Get the right translation for object and language # It should have been done in _post_clean, but instance may have been # changed since. enforce = 'language_code' in self.cleaned_data if getattr(self, 'is_edit', False): language = self.language or get_language() else: language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) # Fill the translated fields with values from the form excludes = list(self._meta.exclude) + ['master', 'language_code'] translation = construct_instance(self, translation, self._meta.fields, excludes) if getattr(self, 'is_edit', False): translation.language_code = \ self.cleaned_data.get('language_code', None) or self.new_lang set_cached_translation(self.instance, translation) # Delegate shared fields to super() return super(BaseTranslatableModelForm, self).save(commit=commit)
def save_new(self, form, commit=True): kwargs = { self.ct_field.get_attname(): ContentType.objects.get_for_model( self.instance, for_concrete_model=self.for_concrete_model).pk, self.ct_fk_field.get_attname(): self.instance.pk, } form.instance = construct_instance(form, self.model(**kwargs)) return form.save(commit=commit)
def test_empty_fields_to_construct_instance(self): "No fields should be set on a model instance if construct_instance receives fields=()" form = modelform_factory(Person, fields="__all__")({ 'name': 'John Doe' }) self.assertTrue(form.is_valid()) instance = construct_instance(form, Person(), fields=()) self.assertEqual(instance.name, '')
def save_instance(self, instance, fields=None, fail_message='saved', commit=True, exclude=None, construct=True): """ Saves bound Form ``form``'s cleaned_data into model instance ``instance``. If commit=True, then the changes to ``instance`` will be saved to the database. Returns ``instance``. If construct=False, assume ``instance`` has already been constructed and just needs to be saved. """ if construct: instance = construct_instance(self, instance, fields, exclude) opts = instance._meta if self.errors: raise ValueError("the %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) # wrap up the saving of m2m data as a function. def save_m2m(instance): cleaned_data = self.cleaned_data for f in opts.many_to_many: if fields and f.name not in fields: continue if f.name in cleaned_data: for validator in f.validators: validator(instance, cleaned_data[f.name]) f.save_form_data(instance, cleaned_data[f.name]) if commit: # TODO XXX, why are we not using transactions? # if we are committing, save the instance and the m2m data # immediately. if not instance.pk: rollback = True else: rollback = False instance.save() try: save_m2m(instance) # ^-- pass instance so we can validate it's views except ValidationError: if rollback: self.delete_instance(instance) # we didn't call ensure_label_domain so it's not our # responsibility to call prune_tree raise else: # we're not committing. add a method to the form to allow deferred # saving of m2m data. self.save_m2m = save_m2m return instance
def done(self, form_list, form_dict, **kwargs): try: client = Client.objects.get( mail=self.request.POST.get('step2-mail', False)) except Client.DoesNotExist: client = Client() form_client_step_2 = form_dict['step2'] client = construct_instance(form_client_step_2, client, form_client_step_2.fields) client.save() order = Order() template_options = form_dict['step1'] order = construct_instance(template_options, order, template_options.fields) order.client = Client.objects.get(id=client.pk) order.save() for i in template_options.cleaned_data['packages']: order.packages.add(i) m = client.mail send_templated_mail( template_name='lol', from_email='*****@*****.**', recipient_list=[m], context={ "order": order, "client": client, }, # Optional: # cc=['*****@*****.**'], # bcc=['*****@*****.**'], # headers={'My-Custom-Header':'Custom Value'}, # template_prefix="my_emails/", # template_suffix="email", ) return render(self.request, 'step_final.html', {'mail': m})
def clean_join_form(form): from foundry.forms import JoinForm from django.forms.models import construct_instance cleaned_data = super(JoinForm, form).clean() opts = form._meta # Update the model instance with cleaned_data. member = construct_instance(form, form.instance, opts.fields, opts.exclude) member.set_password(form.cleaned_data["password1"]) member.full_clean() return cleaned_data
def clean_join_form(form): cleaned_data = original_clean(form) if not form._errors and not form.non_field_errors(): opts = form._meta # Update the model instance with cleaned_data. member = construct_instance(form, form.instance, opts.fields, opts.exclude) member.set_password(form.cleaned_data["password1"]) member.full_clean() try: form.neoprofile = member.neoprofile except NeoProfile.DoesNotExist: pass return cleaned_data
def _post_clean(self): # must be overriden to bypass instance.clean() if self.cleaned_data.get('_clean', False): opts = self._meta self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude) exclude = self._get_validation_exclusions() for f_name, field in self.fields.items(): if isinstance(field, InlineForeignKeyField): exclude.append(f_name) # Clean the model instance's fields. try: self.instance.clean_fields(exclude=exclude) except ValidationError, e: self._update_errors(e.message_dict)
def _post_clean(self): # must be overriden to bypass instance.clean() if self.cleaned_data.get('_clean', False): opts = self._meta self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude) exclude = self._get_validation_exclusions() for f_name, field in list(self.fields.items()): if isinstance(field, InlineForeignKeyField): exclude.append(f_name) # Clean the model instance's fields. try: self.instance.clean_fields(exclude=exclude) except ValidationError as e: self._update_errors(e.message_dict)
def save_instance(form, instance, fields=None, fail_message='saved', commit=True, exclude=None, construct=True, user=None): """ Saves bound Form ``form``'s cleaned_data into model instance ``instance``. If commit=True, then the changes to ``instance`` will be saved to the database. Returns ``instance``. If construct=False, assume ``instance`` has already been constructed and just needs to be saved. """ if construct: instance = construct_instance(form, instance, fields, exclude) opts = instance._meta if form.errors: raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) # Wrap up the saving of m2m data as a function. def save_m2m(): cleaned_data = form.cleaned_data # Note that for historical reasons we want to include also # virtual_fields here. (GenericRelation was previously a fake # m2m field). for f in list(opts.many_to_many) + opts.private_fields: if not hasattr(f, 'save_form_data'): continue if fields and f.name not in fields: continue if exclude and f.name in exclude: continue if f.name in cleaned_data: f.save_form_data(instance, cleaned_data[f.name]) if commit: # If we are committing, save the instance and the m2m data immediately. instance.save(user=user) save_m2m() else: # We're not committing. Add a method to the form to allow deferred # saving of m2m data. form.save_m2m = save_m2m return instance
def _post_clean(self): ''' Switch the translation on self.instance This cannot (and should not) be done in clean() because it could be overriden to change the language. Yet it should be done before save() to allow an overriden save to set some translated field values before invoking super(). ''' enforce = 'language_code' in self.cleaned_data language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) exclude = self._get_validation_exclusions() translation = construct_instance(self, translation, self._meta.fields, exclude) set_cached_translation(self.instance, translation) result = super(BaseTranslatableModelForm, self)._post_clean() return result
def form_valid(self, form): form.instance.updated_by = self.request.user context = self.get_context_data() baseline_form = context['baseline_form'] management_formset = context['formsets']['Management'] outcome_formset = context['formsets']['Outcome'] if baseline_form.is_valid() and management_formset.is_valid() and outcome_formset.is_valid(): form.instance = construct_instance(baseline_form, form.instance) management_formset.instance = self.object for management_instance in management_formset.save(commit=False): management_instance.updated_by = self.request.user management_instance.save() outcome_formset.instance = self.object for outcome_instance in outcome_formset.save(commit=False): outcome_instance.updated_by = self.request.user outcome_instance.save() return super(PatientUpdateView, self).form_valid(form) else: return self.render_to_response(self.get_context_data(form=form))
def clean(self): bulk_edits = self.extra_forms[0].cleaned_data for key in list(bulk_edits.keys()): # get the list because we'll be # changing the dictionary if bulk_edits[key] in ['', None] or key == 'id': del bulk_edits[key] if bulk_edits: for form in self.bulk_forms: for key, value in bulk_edits.items(): if key == 'auto_categories': # categories append, not replace form.cleaned_data[key] = ( list(form.cleaned_data[key]) + list(value)) else: form.cleaned_data[key] = value form.instance = construct_instance(form, form.instance, form._meta.fields, form._meta.exclude) return BaseModelFormSet.clean(self)
def save_instance(form, instance, fields=None, fail_message='saved', commit=True, exclude=None, construct=True, user=None): """ Saves bound Form ``form``'s cleaned_data into model instance ``instance``. If commit=True, then the changes to ``instance`` will be saved to the database. Returns ``instance``. If construct=False, assume ``instance`` has already been constructed and just needs to be saved. """ if construct: instance = construct_instance(form, instance, fields, exclude) opts = instance._meta if form.errors: raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) # Wrap up the saving of m2m data as a function. def save_m2m(): cleaned_data = form.cleaned_data # Note that for historical reasons we want to include also # virtual_fields here. (GenericRelation was previously a fake # m2m field). for f in list(opts.many_to_many) + opts.virtual_fields: if not hasattr(f, 'save_form_data'): continue if fields and f.name not in fields: continue if exclude and f.name in exclude: continue if f.name in cleaned_data: f.save_form_data(instance, cleaned_data[f.name]) if commit: # If we are committing, save the instance and the m2m data immediately. instance.save(user=user) save_m2m() else: # We're not committing. Add a method to the form to allow deferred # saving of m2m data. form.save_m2m = save_m2m return instance
def form_valid(self, form): form.instance.updated_by = self.request.user context = self.get_context_data() baseline_form = context['baseline_form'] management_formset = context['formsets']['Management'] outcome_formset = context['formsets']['Outcome'] if baseline_form.is_valid() and management_formset.is_valid( ) and outcome_formset.is_valid(): form.instance = construct_instance(baseline_form, form.instance) management_formset.instance = self.object for management_instance in management_formset.save(commit=False): management_instance.updated_by = self.request.user management_instance.save() outcome_formset.instance = self.object for outcome_instance in outcome_formset.save(commit=False): outcome_instance.updated_by = self.request.user outcome_instance.save() return super(PatientUpdateView, self).form_valid(form) else: return self.render_to_response(self.get_context_data(form=form))
def save_instance(form, instance, fields=None, fail_message='saved', commit=True, exclude=None, construct=True): """ Saves bound Form ``form``'s cleaned_data into model instance ``instance``. If commit=True, then the changes to ``instance`` will be saved to the database. Returns ``instance``. If construct=False, assume ``instance`` has already been constructed and just needs to be saved. """ if construct: instance = construct_instance(form, instance, fields, exclude) opts = instance._meta if form.errors: raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) # Wrap up the saving of m2m data as a function. def save_m2m(): cleaned_data = form.cleaned_data for f in opts.many_to_many: if fields and f.name not in fields: continue if f.name in cleaned_data: f.save_form_data(instance, cleaned_data[f.name]) if commit: # If we are committing, save the instance and the m2m data immediately. instance.save() save_m2m() else: # We're not committing. Add a method to the form to allow deferred # saving of m2m data. form.save_m2m = save_m2m return instance
def save(self, commit=True): ''' Saves the model If will always use the language specified in self.cleaned_data, with the usual None meaning 'call get_language()'. If instance has another language loaded, it gets reloaded with the new language. If no language is specified in self.cleaned_data, assume the instance is preloaded with correct language. ''' if not self.is_valid(): # raise in 1.3, remove in 1.5 warnings.warn( 'Calling save() on an invalid form is deprecated and ' 'will fail in the future. Check the result of .is_valid() ' 'before calling save().', DeprecationWarning, stacklevel=2) raise ValueError((_( "The %s could not be created because the data didn't validate." ) if self.instance.pk is None else _( "The %s could not be changed because the data didn't validate." )) % self.instance._meta.object_name) # Get the right translation for object and language # It should have been done in _post_clean, but instance may have been # changed since. enforce = 'language_code' in self.cleaned_data language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) # Fill the translated fields with values from the form excludes = list(self._meta.exclude) + ['master', 'language_code'] translation = construct_instance(self, translation, self._meta.fields, excludes) set_cached_translation(self.instance, translation) # Delegate shared fields to super() return super(BaseTranslatableModelForm, self).save(commit=commit)
def save(self, commit=True): ''' Saves the model If will always use the language specified in self.cleaned_data, with the usual None meaning 'call get_language()'. If instance has another language loaded, it gets reloaded with the new language. If no language is specified in self.cleaned_data, assume the instance is preloaded with correct language. ''' if not self.is_valid(): # raise in 1.3, remove in 1.5 warnings.warn('Calling save() on an invalid form is deprecated and ' 'will fail in the future. Check the result of .is_valid() ' 'before calling save().', DeprecationWarning, stacklevel=2) raise ValueError(( _("The %s could not be created because the data didn't validate.") if self.instance.pk is None else _("The %s could not be changed because the data didn't validate.") ) % self.instance._meta.object_name ) # Get the right translation for object and language # It should have been done in _post_clean, but instance may have been # changed since. enforce = 'language_code' in self.cleaned_data language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) # Fill the translated fields with values from the form excludes = list(self._meta.exclude) + ['master', 'language_code'] translation = construct_instance(self, translation, self._meta.fields, excludes) set_cached_translation(self.instance, translation) # Delegate shared fields to super() return super(BaseTranslatableModelForm, self).save(commit=commit)
def add_feed(request): add_form = forms.AddFeedForm(request.GET) if not add_form.is_valid(): return HttpResponseBadRequest(add_form['feed_url'].errors.as_text()) feed_url = add_form.cleaned_data['feed_url'] scraped_feed = add_form.cleaned_data['scraped_feed'] try: scraped_feed.load() except vidscraper.errors.CantIdentifyUrl: return HttpResponseBadRequest( '* It does not appear that %s is an RSS/Atom feed URL.' % (scraped_feed.url, )) except Exception: logging.error('unknown error loading scraped feed: %r', feed_url, exc_info=None) return HttpResponseBadRequest( '* There was an unknown error loading %s' % (feed_url, )) title = scraped_feed.title or '' for regexp in VIDEO_SERVICE_TITLES: match = regexp.match(title) if match: title = match.group(1) break defaults = { 'name': title, 'feed_url': feed_url, 'webpage': scraped_feed.webpage or '', 'description': scraped_feed.description or '', 'etag': scraped_feed.etag or '', 'when_submitted': datetime.datetime.now(), 'last_updated': datetime.datetime.now(), 'status': Feed.INACTIVE, 'user': request.user, 'auto_approve': bool(request.POST.get('auto_approve', False)) } video_count = scraped_feed.entry_count if request.method == 'POST': if 'cancel' in request.POST: return HttpResponseRedirect(reverse('localtv_admin_manage_page')) form = forms.SourceForm(request.POST, instance=Feed(**defaults)) if form.is_valid(): feed, created = Feed.objects.get_or_create( feed_url=defaults['feed_url'], site=SiteSettings.objects.get_current().site, defaults=defaults) if not created: for key, value in defaults.items(): setattr(feed, key, value) construct_instance(form, feed) thumbnail_url = scraped_feed.thumbnail_url if thumbnail_url: try: thumbnail_file = ContentFile( urllib2.urlopen( utils.quote_unicode_url(thumbnail_url)).read()) except IOError: # couldn't get the thumbnail pass else: try: feed.save_thumbnail_from_file(thumbnail_file, update=False) except CannotOpenImageUrl: # couldn't parse the thumbnail. Not sure why this # raises CannotOpenImageUrl, tbh. pass if feed.video_service(): user, created = User.objects.get_or_create( username=feed.name[:30], defaults={'email': ''}) if created: user.set_unusable_password() Profile.objects.create(user=user, website=defaults['webpage']) user.save() feed.auto_authors.add(user) feed.save() tasks.feed_update.delay(feed.pk, using=tasks.CELERY_USING, clear_rejected=True) return HttpResponseRedirect(reverse('localtv_admin_manage_page')) else: form = forms.SourceForm(instance=Feed(**defaults)) return render_to_response('localtv/admin/add_feed.html', { 'form': form, 'video_count': video_count }, context_instance=RequestContext(request))
def add_feed(request): add_form = forms.AddFeedForm(request.GET) if not add_form.is_valid(): return HttpResponseBadRequest( add_form['feed_url'].errors.as_text()) feed_url = add_form.cleaned_data['feed_url'] scraped_feed = add_form.cleaned_data['scraped_feed'] try: scraped_feed.load() except vidscraper.errors.CantIdentifyUrl: return HttpResponseBadRequest( '* It does not appear that %s is an RSS/Atom feed URL.' % ( scraped_feed.url,)) except Exception: logging.error('unknown error loading scraped feed: %r', feed_url, exc_info=None) return HttpResponseBadRequest( '* There was an unknown error loading %s' % ( feed_url,)) title = scraped_feed.title or '' for regexp in VIDEO_SERVICE_TITLES: match = regexp.match(title) if match: title = match.group(1) break defaults = { 'name': title, 'feed_url': feed_url, 'webpage': scraped_feed.webpage or '', 'description': scraped_feed.description or '', 'etag': scraped_feed.etag or '', 'when_submitted': datetime.datetime.now(), 'last_updated': datetime.datetime.now(), 'status': Feed.INACTIVE, 'user': request.user, 'auto_approve': bool(request.POST.get('auto_approve', False))} video_count = scraped_feed.entry_count if request.method == 'POST': if 'cancel' in request.POST: return HttpResponseRedirect(reverse('localtv_admin_manage_page')) form = forms.SourceForm(request.POST, instance=Feed(**defaults)) if form.is_valid(): feed, created = Feed.objects.get_or_create( feed_url=defaults['feed_url'], site=SiteSettings.objects.get_current().site, defaults=defaults) if not created: for key, value in defaults.items(): setattr(feed, key, value) construct_instance(form, feed) thumbnail_url = scraped_feed.thumbnail_url if thumbnail_url: try: thumbnail_file = ContentFile( urllib2.urlopen( utils.quote_unicode_url(thumbnail_url)).read()) except IOError: # couldn't get the thumbnail pass else: try: feed.save_thumbnail_from_file(thumbnail_file, update=False) except CannotOpenImageUrl: # couldn't parse the thumbnail. Not sure why this # raises CannotOpenImageUrl, tbh. pass if feed.video_service(): user, created = User.objects.get_or_create( username=feed.name[:30], defaults={'email': ''}) if created: user.set_unusable_password() Profile.objects.create( user=user, website=defaults['webpage']) user.save() feed.auto_authors.add(user) feed.save() tasks.feed_update.delay( feed.pk, using=tasks.CELERY_USING, clear_rejected=True) return HttpResponseRedirect(reverse('localtv_admin_manage_page')) else: form = forms.SourceForm(instance=Feed(**defaults)) return render_to_response('localtv/admin/add_feed.html', {'form': form, 'video_count': video_count}, context_instance=RequestContext(request))
def done(self, form_list, **kwargs): personal_details_instance = PersonalDetails() personal_contact_instance = PersonalContactDetail() transport_allocation_instance = TransportAllocation() hostel_allocation_instance = HostelAllocation() qualification_instance = Qualification() fee_collection_instance = FeeCollection() student_registration_instance = StudentRegistration() student_registration_instance.created_by = self.request.user student_registration_instance.personal_details = personal_details_instance student_registration_instance.personal_contact_detail = personal_contact_instance student_registration_instance.transport_allocation = transport_allocation_instance student_registration_instance.hostel_allocation = hostel_allocation_instance student_registration_instance.qualification = qualification_instance student_registration_instance.feecollection = fee_collection_instance for form in form_list: personal_details_instance = construct_instance( form, personal_details_instance, form._meta.fields, form._meta.exclude) personal_contact_instance = construct_instance( form, personal_contact_instance, form._meta.fields, form._meta.exclude) transport_allocation_instance = construct_instance( form, transport_allocation_instance, form._meta.fields, form._meta.exclude) hostel_allocation_instance = construct_instance( form, hostel_allocation_instance, form._meta.fields, form._meta.exclude) qualification_instance = construct_instance( form, qualification_instance, form._meta.fields, form._meta.exclude) fee_collection_instance = construct_instance( form, fee_collection_instance, form._meta.fields, form._meta.exclude) student_registration_instance = construct_instance( form, student_registration_instance, form._meta.fields, form._meta.exclude) personal_details_instance.save() personal_contact_instance.save() transport_allocation_instance.save() hostel_allocation_instance.save() qualification_instance.save() fee_collection_instance.save() student_registration_instance.save() return render(self.request, 'students/done.html', { 'form_data': [form.cleaned_data for form in form_list], })
def data_valid(self,sendtype): obj= construct_instance(self, instance, fields) if hasattr(obj,"data_valid"): return obj.data_valid(sendtype) else: pass
def save_instance(form, instance, fields=None, fail_message='saved', commit=True, exclude=None, construct=True): """ Saves bound Form ``form``'s cleaned_data into model instance ``instance``. If commit=True, then the changes to ``instance`` will be saved to the database. Returns ``instance``. If construct=False, assume ``instance`` has already been constructed and just needs to be saved. This is almost identical to django's default ``save_instance``, except we add ``save_fk`` method which needs to be called before saving the instance in order to save those objects pointed to with a foreign key. """ if construct: instance = construct_instance(form, instance, fields, exclude) opts = instance._meta if form.errors: raise ValueError("The %s could not be %s because the data didn't" " validate." % (opts.object_name, fail_message)) self_save_fk = getattr(form, 'save_fk', None) def save_fk(): if self_save_fk: self_save_fk() cleaned_data = form.cleaned_data for f in opts.fields: if not isinstance(f, ForeignKey): continue if fields is not None and f.name not in fields: continue if exclude and f.name in exclude: continue if f.name in cleaned_data: data = cleaned_data[f.name] data.save() f.save_form_data(instance, data) # Wrap up the saving of m2m data as a function. self_save_m2m = getattr(form, 'save_m2m', None) def save_m2m(): if self_save_m2m: self_save_m2m() cleaned_data = form.cleaned_data for f in opts.many_to_many: if fields is not None and f.name not in fields: continue if exclude and f.name in exclude: continue if f.name in cleaned_data: f.save_form_data(instance, cleaned_data[f.name]) for f in form.fields.values(): if isinstance(f, InlineFormSetField): if not f.widget.instance.pk: f.widget.instance = instance f.widget.save() if commit: # If we are committing, save the instance and the m2m data immediately. save_fk() instance.save() save_m2m() else: # We're not committing. Add a method to the form to allow deferred # saving of m2m data. form.save_fk = save_fk form.save_m2m = save_m2m return instance
def modify_event_view(request, event_id=None, *args, **kwargs): active_link_id = "event" hash = 'event-tab' main_person_form = PersonForm(auto_id='%s', prefix="main") person_form_prefix = 'person_from' person_form_number = 1 if event_id: action = reverse('edit_event', args=[event_id]) event_instance = get_object_or_404(Event, pk=int(event_id)) else: action = reverse('add_event') event_instance = None if request.method == 'POST': event_form = EventForm(request.POST, request.FILES, instance=event_instance, auto_id='%s') if request.user.is_authenticated(): del event_form.fields['captcha'] existing_persons_form = ExistingPersonsForm(request.POST, request.FILES, instance=event_instance, auto_id='%s') person_forms = [] person_form_prefixes = filter(lambda p: p, request.POST['new_persons'].split(",")) existing_persons_form.fields['new_persons'].initial = ",".join(person_form_prefixes) for prefix in person_form_prefixes: person_forms.append(PersonForm(request.POST, request.FILES, auto_id='%s', prefix=prefix)) person_form_number = max(map(lambda p: int(p.replace(person_form_prefix, "")), person_form_prefixes) or [0]) + 1 error = False if not event_form.is_valid(): error = True hash = 'event-tab' for person_form in person_forms: if not person_form.is_valid(): error = True hash = 'person-tab' if not error: # Save event event = construct_instance(event_form, event_form.instance, ['subject', 'date_happened', 'date_ended', 'location', 'description', 'actions_taken', 'related_events']) if 'photo' in request.FILES: try: os.remove("%s/%s" % (settings.EVENT_IMAGES_DIR , request.POST['photo_path'])) except: pass event.photo = save_request_file(settings.EVENT_IMAGES_DIR, request.FILES['photo']) elif event_instance: if 'remove_photo' not in request.POST: event.photo = request.POST.get('photo_path', None) else: try: os.remove("%s/%s" % (settings.EVENT_IMAGES_DIR , event.photo)) except: pass event.photo = None if not request.user.is_authenticated(): event.status = 'unconfirmed' if request.user.is_authenticated(): event.modified_by = request.user event.save() # Save tags if event_instance: for i in event.tags.all(): event.tags.remove(i) for i in request.POST.getlist('tags'): tag = Tag.objects.get(id=int(i)) event.tags.add(tag) # Save related events if event_instance: for i in event.related_events.all(): event.related_events.remove(i) for i in request.POST.getlist('related_events'): related_event = Event.objects.get(id=int(i)) if related_event != event: event.related_events.add(related_event) # Save attachments for attachment in request.POST.getlist('remove_attachments'): attachment = Attachment.objects.get(id=int(attachment)) try: os.remove("%s/%s" % (settings.EVENT_ATTACHMENTS_DIR , attachment.filename)) except: pass attachment.delete() for attachment in request.FILES.getlist('attachments'): filename = save_request_file(settings.EVENT_ATTACHMENTS_DIR, attachment) Attachment.objects.create(name=attachment.name, filename=filename, event=event) # Save persons if event_instance: for i in event.persons.all(): event.persons.remove(i) for i in request.POST.getlist('persons'): person = Person.objects.get(id=int(i)) event.persons.add(person) for person_form in person_forms: person = person_form.save() if not request.user.is_authenticated(): person.status = 'unconfirmed' if request.user.is_authenticated(): person.modified_by = request.user person.save() person_photo = '%s-person_photo' % person_form.prefix if person_photo in request.FILES: person.person_photo = save_request_file(settings.PERSON_IMAGES_DIR, request.FILES[person_photo]) person.save() event.persons.add(person) return redirect(reverse('detail_event', args=[event.id])) else: event_form.fields['date_happened'].widget.attrs.update({'data-ignore-convert':'1'}) event_form.fields['date_ended'].widget.attrs.update({'data-ignore-convert':'1'}) for person_form in person_forms: person_form.fields['birth_date'].widget.attrs.update({'data-ignore-convert':'1'}) person_form.fields['death_date'].widget.attrs.update({'data-ignore-convert':'1'}) else: event_form = EventForm(instance=event_instance, auto_id='%s') if request.user.is_authenticated(): del event_form.fields['captcha'] existing_persons_form = ExistingPersonsForm(instance=event_instance, auto_id='%s') person_forms = [] title = 'ارسال رویداد جدید' if not request.user.is_authenticated() else ('ایجاد رویداد جدید' if not event_id else 'ویرایش رویداد') event_photo = event_instance and event_instance.photo or '' attachments = event_instance.attachments.all() if event_instance else [] return render_to_response('event/modify.html', locals(), context_instance = RequestContext(request))
def data_valid(self, sendtype): obj = construct_instance(self, instance, fields) if hasattr(obj, "data_valid"): return obj.data_valid(sendtype) else: pass
def test_empty_fields_to_construct_instance(self): "No fields should be set on a model instance if construct_instance receives fields=()" form = modelform_factory(Person, fields="__all__")({'name': 'John Doe'}) self.assertTrue(form.is_valid()) instance = construct_instance(form, Person(), fields=()) self.assertEqual(instance.name, '')