def monkeypatch_user(sender, **kwargs): profile_model = get_profile_model() exclude_names = set(field.name for field in User._meta.fields) exclude_names.add('user') if include is not None: if exclude is not None: raise ValueError('Cannot pass both "include" and "exclude"') include_names = set(include) - exclude_names iterfields = (field for field in profile_model._meta.fields if field.name in include_names) else: if exclude: exclude_names.update(exclude) iterfields = (field for field in profile_model._meta.fields if field.name not in exclude_names) for field in iterfields: name = field.name setattr_if_unset(User, name, _make_profile_property(name)) if field.choices: setattr_if_unset(User, 'get_%s_display' % name, curry(User._get_FIELD_display, field=field)) if isinstance(field, (DateField, DateTimeField)) and not field.null: setattr_if_unset(User, 'get_next_by_%s' % name, curry(_get_next_or_previous_by_profile_FIELD, field=field, is_next=True)) setattr_if_unset(User, 'get_previous_by_%s' % name, curry(_get_next_or_previous_by_profile_FIELD, field=field, is_next=False)) post_save.connect(_save_profile_listener, sender=User) connection_created.disconnect(monkeypatch_user)
def contribute_to_class(self, cls, name): super(DateField,self).contribute_to_class(cls, name) if not self.null: setattr(cls, 'get_next_by_%s' % self.name, curry(cls._get_next_or_previous_by_FIELD, field=self, is_next=True)) setattr(cls, 'get_previous_by_%s' % self.name, curry(cls._get_next_or_previous_by_FIELD, field=self, is_next=False))
def process_request(self, request): if getattr(settings, 'DISABLE_AUDIT_LOG', False): return update_pre_save_info = curry(self._update_pre_save_info, request) update_post_save_info = curry(self._update_post_save_info, request) signals.pre_save.connect(update_pre_save_info, dispatch_uid=(self.__class__, request,), weak = False) signals.post_save.connect(update_post_save_info, dispatch_uid=(self.__class__, request,), weak = False)
def contribute_to_class(self, cls, name): super(StateField, self).contribute_to_class(cls, name) # Set choice options (for combo box) self._choices = self._machine.get_state_choices() self.default = self._machine.initial_state # do we need logging? if self._machine.log_transitions: from states2.log import _create_state_log_model log_model = _create_state_log_model(cls, name, self._machine) else: log_model = None setattr(cls, '_%s_log_model' % name, log_model) # adding extra methods setattr(cls, 'get_%s_transitions' % name, curry(get_STATE_transitions, field=name)) setattr(cls, 'get_public_%s_transitions' % name, curry(get_public_STATE_transitions, field=name)) setattr(cls, 'get_%s_info' % name, curry(get_STATE_info, field=name, machine=self._machine)) setattr(cls, 'get_%s_machine' % name, curry(get_STATE_machine, field=name, machine=self._machine)) models.signals.class_prepared.connect(self.finalize, sender=cls)
def contribute_to_class(self, cls, name): ensure_class_has_cached_field_methods(cls) self.name = name setattr(cls, 'recalculate_{}'.format(self.name), curry(cls._recalculate_FIELD, field=self)) setattr(cls, self.name, property(curry(cls._get_FIELD, field=self), curry(cls._set_FIELD, field=self))) proper_field = (set(type(self).__bases__) - set((CachedFieldMixin,))).pop() # :MC: ew. proper_field = proper_field(*self.init_args_for_field, **self.init_kwargs_for_field) setattr(cls, self.cached_field_name, proper_field) proper_field.contribute_to_class(cls, self.cached_field_name) flag_field = models.BooleanField( default=True, db_index=self.db_index_on_recalculation_needed_field) setattr(cls, self.recalculation_needed_field_name, flag_field) flag_field.contribute_to_class(cls, self.recalculation_needed_field_name) if self.temporal_triggers: setattr(cls, 'expire_{}_after'.format(self.name), curry(cls._expire_FIELD_after, field=self)) expire_field = models.DateTimeField( null=True, db_index=self.db_index_on_temporal_trigger_field) setattr(cls, self.expiration_field_name, expire_field) expire_field.contribute_to_class(cls, self.expiration_field_name) setattr(cls, 'flag_{}_as_stale'.format(self.name), curry(cls._flag_FIELD_as_stale, field=self))
def _prepare(cls): """ Creates some methods once self._meta has been populated. """ opts = cls._meta opts._prepare(cls) if opts.order_with_respect_to: cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True) cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False) # defer creating accessors on the foreign class until we are # certain it has been created def make_foreign_order_accessors(field, model, cls): setattr(field.rel.to, "get_%s_order" % cls.__name__.lower(), curry(method_get_order, cls)) setattr(field.rel.to, "set_%s_order" % cls.__name__.lower(), curry(method_set_order, cls)) add_lazy_relation( cls, opts.order_with_respect_to, opts.order_with_respect_to.rel.to, make_foreign_order_accessors ) # Give the class a docstring -- its definition. if cls.__doc__ is None: cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join(f.attname for f in opts.fields)) if hasattr(cls, "get_absolute_url"): cls.get_absolute_url = update_wrapper( curry(get_absolute_url, opts, cls.get_absolute_url), cls.get_absolute_url ) signals.class_prepared.send(sender=cls)
def add_m2m_table(self, app_label, proj_sig): app_sig = proj_sig[app_label] model_sig = app_sig[self.model_name] model = MockModel(proj_sig, app_label, self.model_name, model_sig) field = create_field(proj_sig, self.field_name, self.field_type, self.field_attrs, model) related_app_label, related_model_name = \ self.field_attrs['related_model'].split('.') related_sig = proj_sig[related_app_label][related_model_name] related_model = MockModel(proj_sig, related_app_label, related_model_name, related_sig) related = MockRelated(related_model, model, field) if hasattr(field, '_get_m2m_column_name'): # Django < 1.2 field.m2m_column_name = curry(field._get_m2m_column_name, related) field.m2m_reverse_name = curry(field._get_m2m_reverse_name, related) else: # Django >= 1.2 field.m2m_column_name = curry(field._get_m2m_attr, related, 'column') field.m2m_reverse_name = curry(field._get_m2m_reverse_attr, related, 'column') sql_statements = self.evolver(model).add_m2m_table(model, field) return sql_statements
def wiki_links(text, group=None): """Replaces CamelCase words to wiki-links.""" from BeautifulSoup import BeautifulSoup autoescape = False safe_input = isinstance(text, SafeData) conditional_escape(text) soup = BeautifulSoup(text) for url in soup.findAll(text=wikiword_link): if url.parent.name == 'a': continue new_str = wikiword_link.sub(curry(_re_callback, inside=False, group=group), url) url.replaceWith(BeautifulSoup(new_str)) soup = BeautifulSoup(str(soup)) # Fixed for bug in some versions of BS for a in soup.findAll('a'): url = a.get('href') if not url: continue new_str = wikiword_link_href.sub(curry(_re_callback, inside=True, group=group), url) if new_str != url: a['href'] = new_str result = force_unicode(soup) if safe_input: result = mark_safe(result) elif autoescape: result = escape(result) return result
def contribute_to_class(self, cls, name): self.name = self.attname = name cls._meta.add_virtual_field(self) self.inherit_flag_name = INHERIT_FLAG_NAME % name self.value_field_name = VALUE_FIELD_NAME % name if not self.inherit_only: flag_field = BooleanField(default=True) flag_field.creation_counter = self.creation_counter # Adjust the creation_counter # cls.add_to_class(self.inherit_flag_name, flag_field) flag_field.contribute_to_class(cls, self.inherit_flag_name) signals.class_prepared.connect( curry(self.add_value_field, name=name), sender=cls, weak=False ) setattr(cls, name, self) display_name = 'get_%s_display' % name setattr(cls, display_name, curry(self.get_field_display, name=name)) getattr(cls, display_name).__dict__['short_description'] = name.replace('_', ' ') if not hasattr(cls, 'FIELD_INHERITANCE_MAP'): #TODO: test cls.FIELD_INHERITANCE_MAP = {} cls.FIELD_INHERITANCE_MAP[name] = (self.parent_object_field_name, self.inherited_field_name_in_parent or name) signals.class_prepared.connect(self.patch_manager, sender=cls)
def process_request(self, request): if request.method not in ('GET', 'HEAD', 'OPTIONS', 'TRACE'): if hasattr(request, 'user') and request.user.is_authenticated(): user = request.user else: user = None session = request.session.session_key self.ip_address = request.META.get('REMOTE_ADDR', None) update_post_save_info = curry( self._update_post_save_info, user, session, ) update_post_delete_info = curry( self._update_post_delete_info, user, session, ) signals.post_save.connect( update_post_save_info, dispatch_uid=(self.__class__, request,), weak=False ) signals.post_delete.connect( update_post_delete_info, dispatch_uid=(self.__class__, request,), weak=False )
def add_m2m_table(self, app_label, proj_sig, database): app_sig = proj_sig[app_label] model_sig = app_sig[self.model_name] model = MockModel(proj_sig, app_label, self.model_name, model_sig) field = create_field(proj_sig, self.field_name, self.field_type, self.field_attrs, model) related_app_label, related_model_name = self.field_attrs["related_model"].split(".") related_sig = proj_sig[related_app_label][related_model_name] related_model = MockModel(proj_sig, related_app_label, related_model_name, related_sig) related = MockRelated(related_model, model, field) if hasattr(field, "_get_m2m_column_name"): # Django < 1.2 field.m2m_column_name = curry(field._get_m2m_column_name, related) field.m2m_reverse_name = curry(field._get_m2m_reverse_name, related) else: # Django >= 1.2 field.m2m_column_name = curry(field._get_m2m_attr, related, "column") field.m2m_reverse_name = curry(field._get_m2m_reverse_attr, related, "column") evolver = self.evolver(model, database) sql_statements = evolver.add_m2m_table(model, field) return sql_statements
def add_m2m_table(self, mutator, model): field = create_field(mutator.proj_sig, self.field_name, self.field_type, self.field_attrs, model) related_app_label, related_model_name = \ self.field_attrs['related_model'].split('.') related_sig = mutator.proj_sig[related_app_label][related_model_name] related_model = MockModel(mutator.proj_sig, related_app_label, related_model_name, related_sig, mutator.database) related = MockRelated(related_model, model, field) if hasattr(field, '_get_m2m_column_name'): # Django < 1.2 field.m2m_column_name = \ curry(field._get_m2m_column_name, related) field.m2m_reverse_name = \ curry(field._get_m2m_reverse_name, related) else: # Django >= 1.2 field.m2m_column_name = curry(field._get_m2m_attr, related, 'column') field.m2m_reverse_name = curry(field._get_m2m_reverse_attr, related, 'column') mutator.add_sql(self, mutator.evolver.add_m2m_table(model, field))
def add_camara_text_utils_to_class(cls): """ Adds camara values text representation utils to model fields whose `choices` is ``CAMARA_CHOICES`` Added instance methods: - get_<fname>_slug(): slug text representation for camara value. - get_<fname>_display_long(): long text representation for camara value. - get_<fname>_display_short(): short text representation for camara value. This is the same value exposed by get_<fname>_display by default. """ def _get_display(obj, attr, displays, default=u""): return displays.get(getattr(obj, attr), default) for f in cls._meta.fields: if f.choices is CAMARA_CHOICES: cls.add_to_class("get_%s_slug" % f.name, curry(_get_display, attr=f.name, displays=CAMARA_SLUGS)) cls.add_to_class( "get_%s_display_long" % f.name, curry(_get_display, attr=f.name, displays=CAMARA_DISPLAYS_LONG) ) # this is the same as self.get_<fname>_display. Added just for completeness cls.add_to_class( "get_%s_display_short" % f.name, curry(_get_display, attr=f.name, displays=CAMARA_DISPLAYS_SHORT) )
def edit(request, id): provider = request.user.service_provider employee = get_object_or_404(Employee, employer=request.user.service_provider, id=id) hours = EmployeeWorkingHours.objects.filter(employee=employee) services = Service.objects.filter(service_provider=provider, employees__in=[employee.id]) if request.method == 'POST': if request.POST.get('action') == 'delete': EmployeeWorkingHours.objects.get(id=request.POST.get('workinghours')).delete() return HttpResponseRedirect('/myemployees/edit/' + id) form = EmployeeForm(request.POST, request.FILES, instance=employee) qs = EmployeeWorkingHours.objects.filter(employee=employee) EmployeeWorkingHoursFormSet.form = staticmethod(curry(EmployeeWorkingHoursForm, employee=employee)) forms = EmployeeWorkingHoursFormSet(request.POST) form_s = EmployeeServicesForm(request.POST, service_provider=provider, employee=employee, data=services) form_valid = form.is_valid() form_s_valid = form_s.is_valid() forms_valid = True for f in forms: if not f.is_valid(): forms_valid = False if form_valid and form_s_valid and forms_valid: form.save() for f in forms: f.save() form_s.save() return HttpResponseRedirect(reverse(myemployees)) else: form = EmployeeForm(instance=employee) qs = EmployeeWorkingHours.objects.filter(employee=employee) EmployeeWorkingHoursFormSet.form = staticmethod(curry(EmployeeWorkingHoursForm, employee=employee)) forms = EmployeeWorkingHoursFormSet(queryset=qs) form_s = EmployeeServicesForm(service_provider=provider, employee=employee, data=services) return render_to_response('employees/edit.html', locals(), context_instance=RequestContext(request))
def contribute_to_class(self, cls, name): assert not hasattr(cls._meta, 'has_ordering_field'), "A model can't have more than one OrderingField." super(OrderingField, self).contribute_to_class(cls, name) setattr(cls._meta, 'has_ordering_field', True) setattr(cls._meta, 'ordering_field', self) setattr(cls, 'move_up', curry(cls._move_up_or_down, is_up=True)) setattr(cls, 'move_down', curry(cls._move_up_or_down, is_up=False))
def _prepare(cls): """ Creates some methods once self._meta has been populated. """ opts = cls._meta opts._prepare(cls) if opts.order_with_respect_to: cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True) cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False) setattr( opts.order_with_respect_to.rel.to, "get_%s_order" % cls.__name__.lower(), curry(method_get_order, cls) ) setattr( opts.order_with_respect_to.rel.to, "set_%s_order" % cls.__name__.lower(), curry(method_set_order, cls) ) # Give the class a docstring -- its definition. if cls.__doc__ is None: cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields])) if hasattr(cls, "get_absolute_url"): cls.get_absolute_url = update_wrapper( curry(get_absolute_url, opts, cls.get_absolute_url), cls.get_absolute_url ) signals.class_prepared.send(sender=cls)
def _contribute_thumbnail(self, cls, name, thumbnail): func = curry(_get_thumbnail, field=self, attrs=thumbnail) tag_func = curry(_get_thumbnail_tag, field=self, attrs=thumbnail) # Make it safe for contrib.admin tag_func.allow_tags = True setattr(cls, 'get_%s_thumbnail' % name, func) setattr(cls, 'get_%s_thumbnail_tag' % name, tag_func)
def test_moved_object(self): obj_a = EventPageSpeaker( first_name="Father", last_name="Christmas", sort_order=1, ) obj_b = EventPageSpeaker( first_name="Father", last_name="Christmas", sort_order=5, ) comparison = self.comparison_class( EventPageSpeaker, [ curry(self.field_comparison_class, EventPageSpeaker._meta.get_field('first_name')), curry(self.field_comparison_class, EventPageSpeaker._meta.get_field('last_name')), ], obj_a, obj_b, ) self.assertFalse(comparison.is_addition()) self.assertFalse(comparison.is_deletion()) self.assertFalse(comparison.has_changed()) self.assertEqual(comparison.get_position_change(), 4) self.assertEqual(comparison.get_num_differences(), 0)
def carousel(context, contents, min_photos=5, max_photos=50): """ This will put a carousel of destination and tourists resource images. "contents" parameter has to be a queryset of BaseContent objects Example usage:: {% load slide_tags %} {% block content %} {% secundary_carousel location resources %} {% endblock %} """ excludes = {'main_image': ''} relative_contents = contents.exclude(**excludes).extra(select={'RANDOM': "RANDOM()"}).distinct().order_by("?") photos_bag = PhotosBag(min_photos, max_photos) photos_bag.add_collector(curry(_add_main_photos_relative_content, relative_contents)) photos_bag.add_collector(curry(_add_second_photos, relative_contents)) photos = photos_bag.collect_photos() return {'photos': photos, 'MEDIA_URL': context.get('MEDIA_URL', '/media/'), 'LANGUAGE_CODE': context.get('LANGUAGE_CODE', 'es'), 'request': context.get('request', None)}
def setUp(self): self.client.put = curry(self.client.post, REQUEST_METHOD='PUT') self.client.delete = curry(self.client.get, REQUEST_METHOD='DELETE') self.headers = {'HTTP_AUTHORIZATION': 'Basic %s' % b2a_base64('rest:rest')[:-1]} self.advancedheaders = {'HTTP_AUTHORIZATION': 'Basic %s' % b2a_base64('restadvanced:restadvanced')[:-1]} self.adminheaders = {'HTTP_AUTHORIZATION': 'Basic %s' % b2a_base64('restadmin:restadmin')[:-1]} set_permissions()
def authorize_login(request): initial = {} login_url = 'get_login_view' if request.method == "POST": form = curry(Login, request) else: form = curry(Login, initial=initial) extra_context = {'redirect_field_name': REDIRECT_FIELD_NAME} if request.is_ajax(): template_name = 'auth/_login.html' extra_context['hide'] = True else: template_name = login_url django_login(request, template_name=login_url, authentication_form=form, extra_context=extra_context) if request.user.is_authenticated(): set_session_from_user(request, request.user) redirect = request.POST.get('next', None) or login_url return shortcuts.redirect(redirect)
def contribute_to_class(self, cls, name): super(FileField, self).contribute_to_class(cls, name) setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self)) setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self)) setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self)) setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents, save=True: instance._save_FIELD_file(self, filename, raw_contents, save)) dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
def login(request): """ Logs a user in using the :class:`~openstack_auth.forms.Login` form. """ # Get our initial region for the form. initial = {} current_region = request.session.get("region_endpoint", None) requested_region = request.GET.get("region", None) regions = dict(getattr(settings, "AVAILABLE_REGIONS", [])) if requested_region in regions and requested_region != current_region: initial.update({"region": requested_region}) if request.method == "POST": form = curry(Login, request) else: form = curry(Login, initial=initial) extra_context = {"redirect_field_name": REDIRECT_FIELD_NAME} if request.is_ajax(): template_name = "auth/_login.html" extra_context["hide"] = True else: template_name = "auth/login.html" res = django_login(request, template_name=template_name, authentication_form=form, extra_context=extra_context) # Set the session data here because django's session key rotation # will erase it if we set it earlier. if request.user.is_authenticated(): set_session_from_user(request, request.user) regions = dict(Login.get_region_choices()) region = request.user.endpoint region_name = regions.get(region) request.session["region_endpoint"] = region request.session["region_name"] = region_name return res
def __init__(self, field, obj): self.field = field self.parent_obj = obj self.original_image = getattr(self.parent_obj, self.field.attname) self.original_image_path = os.path.join(settings.MEDIA_ROOT, str(self.original_image)) self.mangled_name = str(self.original_image) # md5.new('sehkr1tt-%s-%r-%r' % (str(self.original_image), time.time(), id(self))).hexdigest() self.scaled_image_base = os.path.join(settings.MEDIA_ROOT, ',', self.mangled_name) self.broken_image = None # imageid is used for webstorage self.imageid = None # if broken.gif exists we send that if there are any problems during scaling if not os.path.exists(self.original_image_path): # check if we are using web based storage imageid = str(self.original_image) if imageid in huimages._setup_couchdb(): self.original_image_path = huimages.imageurl(imageid) self.imageid = imageid else: self.broken_image = os.path.join(settings.MEDIA_ROOT, 'broken.gif') for size in _sizes: setattr(self, '%s_path' % (size), curry(self.scaled_filename, size)) setattr(self, '%s' % (size), curry(self.scaled_url, size)) setattr(self, '%s_dimensions' % (size), curry(self.scaled_dimensions, size)) setattr(self, '%s_tag' % (size), curry(self.scaled_tag, size))
def __init__(self, queryset, responder, receiver=None, authentication=None, permitted_methods=None, expose_fields=None, entry_class=None, form_class=None): """ queryset: determines the subset of objects (of a Django model) that make up this resource responder: the data format instance that creates HttpResponse objects from single or multiple model objects and renders forms receiver: the data format instance that handles POST and PUT data authentication: the authentication instance that checks whether a request is authenticated permitted_methods: the HTTP request methods that are allowed for this resource e.g. ('GET', 'PUT') expose_fields: the model fields that can be accessed by the HTTP methods described in permitted_methods entry_class: class used for entries in create() and get_entry(); default: class Entry (see below) form_class: base form class used for data validation and conversion in self.create() and Entry.update() """ # Available data self.queryset = queryset # Input format if not receiver: receiver = FormReceiver() self.receiver = receiver # Input validation if not form_class: form_class = ModelForm self.form_class = form_class # Output format / responder setup self.responder = responder if not expose_fields: expose_fields = [field.name for field in queryset.model._meta.fields] responder.expose_fields = expose_fields if hasattr(responder, 'create_form'): responder.create_form = curry(responder.create_form, queryset=queryset, form_class=form_class) if hasattr(responder, 'update_form'): responder.update_form = curry(responder.update_form, queryset=queryset, form_class=form_class) # Resource class for individual objects of the collection if not entry_class: entry_class = Entry self.entry_class = entry_class ResourceBase.__init__(self, authentication, permitted_methods)
def get_mapping(model_or_queryset): '''Get the mapping for a given model or queryset''' mappings = get_mappings() if isinstance(model_or_queryset, models.query.QuerySet): queryset = model_or_queryset model = model_or_queryset.model elif issubclass(model_or_queryset, models.Model): queryset = model_or_queryset.objects.all() model = model_or_queryset else: raise TypeError( 'Only `django.db.model.Model` and `django.db.query.QuerySet` ' 'objects are valid arguments') meta = model._meta mapping_key = meta.app_label + '.' + meta.object_name mapping = mappings.get(mapping_key) if mapping is not None: mapping = mapping.copy() else: raise exceptions.MappingUndefined('Unable to find mapping ' 'for %s' % mapping_key) # The callable allows for customizing the queryset on the fly queryset = mapping.get('queryset', queryset) if callable(queryset): queryset = queryset(mapping) mapping['app'] = meta.app_label mapping['model'] = meta.object_name mapping['queryset'] = queryset mapping.setdefault('separator', ' - ') if 'field' in mapping: mapping['fields'] = mapping['field'], elif 'fields' not in mapping: raise exceptions.ConfigurationError( 'Every mapping should have a field or fields attribute. Mapping: ' '%r' % mapping) mapping.setdefault('split_func', curry( mapping.get('split_func', split_func), mapping['fields'], mapping['separator'], )) mapping.setdefault('join_func', curry( mapping.get('join_func', join_func), mapping['fields'], mapping['separator'], )) mapping.setdefault('filter_func', curry( mapping.get('filter_func', filter_func), mapping['fields'], mapping['separator'], )) return mapping.copy()
def edit_coordinator(request, coordinator): history = History.objects.filter(submitter=request.user, job=coordinator).order_by('-submission_date') DatasetFormSet = inlineformset_factory(Coordinator, Dataset, form=DatasetForm, max_num=0, can_order=False, can_delete=True) DataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, max_num=0, can_order=False, can_delete=True) DataInputFormSet.form = staticmethod(curry(DataInputForm, coordinator=coordinator)) DataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, max_num=0, can_order=False, can_delete=True) DataOutputFormSet.form = staticmethod(curry(DataOutputForm, coordinator=coordinator)) dataset = Dataset(coordinator=coordinator) dataset_form = DatasetForm(instance=dataset, prefix='create') NewDataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, extra=0, can_order=False, can_delete=False) NewDataInputFormSet.form = staticmethod(curry(DataInputForm, coordinator=coordinator)) NewDataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, extra=0, can_order=False, can_delete=False) NewDataOutputFormSet.form = staticmethod(curry(DataOutputForm, coordinator=coordinator)) if request.method == 'POST': coordinator_form = CoordinatorForm(request.POST, instance=coordinator, user=request.user) dataset_formset = DatasetFormSet(request.POST, request.FILES, instance=coordinator) data_input_formset = DataInputFormSet(request.POST, request.FILES, instance=coordinator) data_output_formset = DataOutputFormSet(request.POST, request.FILES, instance=coordinator) new_data_input_formset = NewDataInputFormSet(request.POST, request.FILES, instance=coordinator, prefix='input') new_data_output_formset = NewDataOutputFormSet(request.POST, request.FILES, instance=coordinator, prefix='output') if coordinator_form.is_valid() and dataset_formset.is_valid() and data_input_formset.is_valid() and data_output_formset.is_valid() \ and new_data_input_formset.is_valid() and new_data_output_formset.is_valid(): coordinator = coordinator_form.save() dataset_formset.save() data_input_formset.save() data_output_formset.save() new_data_input_formset.save() new_data_output_formset.save() coordinator.sla = json.loads(request.POST.get('sla')) coordinator.save() request.info(_('Coordinator saved.')) return redirect(reverse('oozie:edit_coordinator', kwargs={'coordinator': coordinator.id})) else: coordinator_form = CoordinatorForm(instance=coordinator, user=request.user) dataset_formset = DatasetFormSet(instance=coordinator) data_input_formset = DataInputFormSet(instance=coordinator) data_output_formset = DataOutputFormSet(instance=coordinator) new_data_input_formset = NewDataInputFormSet(queryset=DataInput.objects.none(), instance=coordinator, prefix='input') new_data_output_formset = NewDataOutputFormSet(queryset=DataOutput.objects.none(), instance=coordinator, prefix='output') return render('editor/edit_coordinator.mako', request, { 'coordinator': coordinator, 'coordinator_form': coordinator_form, 'dataset_formset': dataset_formset, 'data_input_formset': data_input_formset, 'data_output_formset': data_output_formset, 'dataset': dataset, 'dataset_form': dataset_form, 'new_data_input_formset': new_data_input_formset, 'new_data_output_formset': new_data_output_formset, 'history': history })
def contribute_to_class(self, cls, name): super(ImageField, self).contribute_to_class(cls, name) # Add get_BLAH_width and get_BLAH_height methods, but only if the # image field doesn't have width and height cache fields. if not self.width_field: setattr(cls, 'get_%s_width' % self.name, curry(cls._get_FIELD_width, field=self)) if not self.height_field: setattr(cls, 'get_%s_height' % self.name, curry(cls._get_FIELD_height, field=self))
def organisation(request, org_pk): """ Expenses for organisation """ org = Organisation.objects.get(pk=org_pk) expenses = Expense.objects.filter(token__user=request.user, project__organisation=org).order_by('-time') p = Paginator(expenses, 10) page = p.page(request.GET.get('p', 1)) OExpFormset = formset_factory(OfficialExpenseForm) # Use curry to get the form specifically for the organisation OExpFormset.form = staticmethod(curry(OfficialExpenseForm, org)) if request.method == 'POST': formset = OExpFormset(request.POST, request.FILES) if formset.is_valid(): for form in formset: expense = form.save(commit=False) token = AuthToken.objects.get_or_create(user=request.user, site_token=True)[0] expense.token = token if expense.billed: # If expense is billed, create a bill ID in this format: # <user_id><proj_id><token_id><count> expense.bill_id = '%s%s%s%s' %(token.user.id, expense.project.id, token.id, expenses.filter(token=token, billed=True).count()+1) expense.save() return redirect(org) else: initial = { } try: # Fill up the initial data latest = expenses.latest() initial['location'] = latest.location initial['category']=latest.category initial['project']=latest.project except Expense.DoesNotExist: pass # Use the curry utility to pass initial data to forms in # the formset OExpFormset.form = staticmethod(curry(OfficialExpenseForm, org, initial=initial)) formset = OExpFormset() return render(request, 'main/organisation.html', { 'organisation':org, 'page':page, 'formset':formset, })
def fogbow_Login(request, template_name=None, extra_context=None, **kwargs): formChosen = '' formReference = AllForm initial = {} if formChosen == IPConstants.AUTH_KEYSTONE: if (request.user.is_authenticated() and auth.REDIRECT_FIELD_NAME not in request.GET and auth.REDIRECT_FIELD_NAME not in request.POST): return shortcuts.redirect(settings.LOGIN_REDIRECT_URL) current_region = request.session.get('region_endpoint', None) requested_region = request.GET.get('region', None) regions = dict(getattr(settings, 'AVAILABLE_REGIONS', [])) if requested_region in regions and requested_region != current_region: initial.update({'region': requested_region}) if request.method == "POST": if django.VERSION >= (1, 6): form = functional.curry(formReference) else: form = functional.curry(formReference, request) else: form = functional.curry(formReference, initial=initial) if not template_name: if request.is_ajax(): template_name = 'auth/fogbow_login.html' extra_context['hide'] = True else: template_name = 'auth/fogbowlogin.html' if extra_context is None: extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME} extra_context.update(getContextForm()) del extra_context['form'] res = django_auth_views.login(request, template_name=template_name, authentication_form=form, extra_context=extra_context, **kwargs) if request.user.is_authenticated(): if formChosen == IPConstants.AUTH_KEYSTONE: auth_user.set_session_from_user(request, request.user) regions = dict(forms.Login.get_region_choices()) region = request.user.endpoint region_name = regions.get(region) request.session['region_endpoint'] = region request.session['region_name'] = region_name else: request._cached_user = request.user request.user = request.user return res
def get_form(self, *args, **kwargs): form = super(PageAdmin, self).get_form(*args, **kwargs) return curry(form, modeladmin=self)
def login(request, template_name=None, extra_context=None, **kwargs): """Logs a user in using the :class:`~openstack_auth.forms.Login` form.""" # If the user enabled websso and the default redirect # redirect to the default websso url if (request.method == 'GET' and utils.is_websso_enabled and utils.is_websso_default_redirect()): protocol = utils.get_websso_default_redirect_protocol() region = utils.get_websso_default_redirect_region() origin = request.build_absolute_uri('/auth/websso/') url = ('%s/auth/OS-FEDERATION/websso/%s?origin=%s' % (region, protocol, origin)) return shortcuts.redirect(url) # If the user enabled websso and selects default protocol # from the dropdown, We need to redirect user to the websso url if request.method == 'POST': auth_type = request.POST.get('auth_type', 'credentials') if utils.is_websso_enabled() and auth_type != 'credentials': auth_url = getattr(settings, 'WEBSSO_KEYSTONE_URL', request.POST.get('region')) url = utils.get_websso_url(request, auth_url, auth_type) return shortcuts.redirect(url) if not request.is_ajax(): # If the user is already authenticated, redirect them to the # dashboard straight away, unless the 'next' parameter is set as it # usually indicates requesting access to a page that requires different # permissions. if (request.user.is_authenticated and auth.REDIRECT_FIELD_NAME not in request.GET and auth.REDIRECT_FIELD_NAME not in request.POST): return shortcuts.redirect(settings.LOGIN_REDIRECT_URL) # Get our initial region for the form. initial = {} current_region = request.session.get('region_endpoint', None) requested_region = request.GET.get('region', None) regions = dict(getattr(settings, "AVAILABLE_REGIONS", [])) if requested_region in regions and requested_region != current_region: initial.update({'region': requested_region}) if request.method == "POST": form = functional.curry(forms.Login) else: form = functional.curry(forms.Login, initial=initial) if extra_context is None: extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME} extra_context['csrf_failure'] = request.GET.get('csrf_failure') choices = getattr(settings, 'WEBSSO_CHOICES', ()) extra_context['show_sso_opts'] = (utils.is_websso_enabled() and len(choices) > 1) if not template_name: if request.is_ajax(): template_name = 'auth/_login.html' extra_context['hide'] = True else: template_name = 'auth/login.html' res = django_auth_views.login(request, template_name=template_name, authentication_form=form, extra_context=extra_context, **kwargs) # Save the region in the cookie, this is used as the default # selected region next time the Login form loads. if request.method == "POST": utils.set_response_cookie(res, 'login_region', request.POST.get('region', '')) utils.set_response_cookie(res, 'login_domain', request.POST.get('domain', '')) # Set the session data here because django's session key rotation # will erase it if we set it earlier. if request.user.is_authenticated: auth_user.set_session_from_user(request, request.user) regions = dict(forms.Login.get_region_choices()) region = request.user.endpoint login_region = request.POST.get('region') region_name = regions.get(login_region) request.session['region_endpoint'] = region request.session['region_name'] = region_name expiration_time = request.user.time_until_expiration() threshold_days = getattr(settings, 'PASSWORD_EXPIRES_WARNING_THRESHOLD_DAYS', -1) if expiration_time is not None and \ expiration_time.days <= threshold_days: expiration_time = str(expiration_time).rsplit(':', 1)[0] msg = (_('Please consider changing your password, it will expire' ' in %s minutes') % expiration_time).replace( ':', ' Hours and ') messages.warning(request, msg) return res
from rest_framework.decorators import detail_route from rest_framework.response import Response from wagtail.wagtailadmin import messages from variables.models import Variable, RasterRequest from variables.serializers import VariableSerializer, RasterRequestSerializer from variables.data import NODE_TYPES, JobIncompleteException, rpc_con from django.core.serializers.json import DjangoJSONEncoder from django.utils.functional import curry from datetime import date, timedelta import json from psycopg2.extras import DateRange from numpy import isnan json.dumps = curry(json.dumps, cls=DjangoJSONEncoder) def get_raster_catalog(): if not hasattr(settings, 'RPC_URL'): print "Error: RPC_URL must be set in settings.py" try: conn = rpc_con() data = conn.get_catalog() if not data: return [] for r in data: r['start_date'] = r['start_date'].date()
def bulk_chown(*args, **kwargs): op = curry(request.fs.chown, recursive=request.POST.get('recursive', False)) for arg in args: varg = [arg[param] for param in param_names] op(*varg)
def get_mass_upload_context(self, request): model = self.model opts = model._meta self.register_newman_variables(request) # To enable admin-specific fields, we need to run the form class # through modelform_factory using curry FormClass = modelform_factory( Photo, form=MassUploadForm, fields=flatten_fieldsets(self.mass_upload_fieldsets), formfield_callback=curry(self.formfield_for_dbfield, request=request)) context = {} if request.method == 'POST': error_dict = {} # Unfortunately, FLASH uploader sends array data in weird format # so that Django doesn't recognize it as array of values, but # as one string with commas inside. The only way to expect it # and preprocess the values by ourselves. data = dict((key, val) for key, val in request.POST.items()) form = FormClass(data, request.FILES) if form.is_valid(): # To prevent newman from handling our field by common flash editor # we need to use a different mechanism new_object = form.save(commit=False) new_object.image = form.cleaned_data['image_file'] new_object.save() form.save_m2m() context.update({'object': new_object}) else: for e in form.errors: error_dict[u"id_%s" % e] = [u"%s" % ee for ee in form.errors[e]] context.update({'error_dict': error_dict}) else: form = FormClass() adminForm = helpers.AdminForm(form, list(self.mass_upload_fieldsets), self.prepopulated_fields) massUploadForm = helpers.AdminForm(form, list(self.mass_upload2_fieldsets), self.prepopulated_fields) media = self.media + adminForm.media context.update({ 'title': _('Mass upload'), 'adminform': adminForm, 'mass_upload2_form': massUploadForm, 'is_popup': request.REQUEST.has_key('_popup'), 'show_delete': False, 'media': media, 'inline_admin_formsets': [], 'errors': helpers.AdminErrorList(form, ()), 'root_path': self.admin_site.root_path, 'app_label': opts.app_label, 'opts': opts, 'has_change_permission': self.has_change_permission(request, None), 'raw_form': form }) return context
serializers.serialize(format, [obj], indent=2, stream=stream) # Serialize normally for a comparison string_data = serializers.serialize(format, [obj], indent=2) # Check that the two are the same if isinstance(stream, six.StringIO): self.assertEqual(string_data, stream.getvalue()) else: self.assertEqual(string_data, stream.content.decode('utf-8')) stream.close() for format in serializers.get_serializer_formats(): setattr(SerializerTests, 'test_' + format + '_serializer', curry(serializerTest, format)) setattr(SerializerTests, 'test_' + format + '_natural_key_serializer', curry(naturalKeySerializerTest, format)) setattr(SerializerTests, 'test_' + format + '_serializer_fields', curry(fieldsTest, format)) if format != 'python': setattr(SerializerTests, 'test_' + format + '_serializer_stream', curry(streamTest, format)) class XmlDeserializerSecurityTests(TestCase): def test_no_dtd(self): """ The XML deserializer shouldn't allow a DTD. This is the most straightforward way to prevent all entity definitions
objects = [] transaction.enter_transaction_management() transaction.managed(True) for (func, pk, klass, datum) in test_data: objects.append(func[0](pk, klass, datum)) transaction.commit() transaction.leave_transaction_management() # Add the generic tagged objects to the object list objects.extend(Tag.objects.all()) # Serialize the test database serialized_data = serializers.serialize(format, objects, indent=2) # Flush the database and recreate from the serialized data management.flush(verbosity=0, interactive=False) transaction.enter_transaction_management() transaction.managed(True) for obj in serializers.deserialize(format, serialized_data): obj.save() transaction.commit() transaction.leave_transaction_management() # Assert that the deserialized data is the same # as the original source for (func, pk, klass, datum) in test_data: func[1](self, pk, klass, datum) for format in serializers.get_serializer_formats(): setattr(SerializerTests, 'test_'+format+'_serializer', curry(serializerTest, format))
def edit_choices(request, event_id): event = Event.objects.get(id=event_id) # Get all previously made choices for this event previous_choices = ApplicationChoices.objects.filter( person=request.user, event=event_id).order_by("choice_number") max_num = event.allowed_choice_num extra = event.allowed_choice_num - previous_choices.count() # example: initial = [{"choice": "1"}, {"choice": "2"}] initial = [] # Previous choices of the user must come pre-selected in edit form for choice in previous_choices: initial.append({"choice": str(choice.choice.id)}) # example: choices = [("1","1"), ("2","2")] choices = [] # Remove applied course from possible choices for this event try: applied_course = Application.objects.get(person=request.user, course__event=event_id) except Application.DoesNotExist: messages.error(request, _('You did not apply to any course in this event!')) return render_to_response('kurs/hata.html', context_instance=RequestContext(request)) # FIXME: use only courses that are open for application courses = Course.objects.filter(event=event_id).exclude( id=applied_course.course.id) for course in courses: choices.append((course.id, course.display_name)) # initialize form according to allowed_choice_num for the event # the reason we use formset here instead of a regular form is # we do now know in advance how many allowed_choice_num there will be # for a given event. Since the number is dynamic (coming from model/DB) # we have to use formset and generate necessary number of choice drop-down formset = formset_factory(ApplicationChoiceForm, max_num=max_num, extra=extra) formset.form = staticmethod(curry(ApplicationChoiceForm, choices=choices)) if request.method == 'POST': EditChoicesFormSet = formset(request.POST, request.FILES) if EditChoicesFormSet.is_valid(): # Delete all choices made previously in order to overwrite if not previous_choices.count() == 0: for prev_choices in previous_choices: if logger.isEnabledFor(logging.DEBUG): logger.debug( "Tercih silindi: %s , request.user='******' , request.META['REMOTE_ADDR']='%s'" % (prev_choices, request.user, request.META["REMOTE_ADDR"])) previous_choices.delete() # save all applicationchoices of user to the DB choice_number = 1 for choices in EditChoicesFormSet.cleaned_data: record = ApplicationChoices( person=request.user, event=Event.objects.get(id=event_id), choice_number=choice_number, choice=Course.objects.get(id=choices["choice"])) record.save() if logger.isEnabledFor(logging.DEBUG): logger.debug( "Tercih yapıldı: %s , request.user='******' , request.META['REMOTE_ADDR']='%s'" % (record, request.user, request.META["REMOTE_ADDR"])) choice_number += 1 messages.info(request, _('Your choices are saved')) # redirect to his applicationchoice list for this event return HttpResponseRedirect("/kurs/etkinlik/" + event_id + "/tercihler/") else: return render_to_response('kurs/applicationchoices_edit.html', {'formset': formset(initial=initial)}, context_instance=RequestContext(request))
def bulk_chmod(*args, **kwargs): op = curry(request.fs.chmod, recursive=request.POST.get('recursive', False)) for arg in args: op(arg['path'], arg['mode'])
def edit_coordinator(request, coordinator): history = History.objects.filter( submitter=request.user, job=coordinator).order_by('-submission_date') DatasetFormSet = inlineformset_factory(Coordinator, Dataset, form=DatasetForm, max_num=0, can_order=False, can_delete=True) DataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputSetForm, max_num=0, can_order=False, can_delete=True) DataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputSetForm, max_num=0, can_order=False, can_delete=True) dataset = Dataset(coordinator=coordinator) dataset_form = DatasetForm(instance=dataset, prefix='create') NewDataInputFormSet = inlineformset_factory(Coordinator, DataInput, form=DataInputForm, extra=0, can_order=False, can_delete=False) NewDataInputFormSet.form = staticmethod( curry(DataInputForm, coordinator=coordinator)) NewDataOutputFormSet = inlineformset_factory(Coordinator, DataOutput, form=DataOutputForm, extra=0, can_order=False, can_delete=False) NewDataOutputFormSet.form = staticmethod( curry(DataOutputForm, coordinator=coordinator)) if request.method == 'POST': coordinator_form = CoordinatorForm(request.POST, instance=coordinator, user=request.user) dataset_formset = DatasetFormSet(request.POST, request.FILES, instance=coordinator) data_input_formset = DataInputFormSet(request.POST, request.FILES, instance=coordinator) data_output_formset = DataOutputFormSet(request.POST, request.FILES, instance=coordinator) new_data_input_formset = NewDataInputFormSet(request.POST, request.FILES, instance=coordinator, prefix='input') new_data_output_formset = NewDataOutputFormSet(request.POST, request.FILES, instance=coordinator, prefix='output') if coordinator_form.is_valid() and dataset_formset.is_valid() and data_input_formset.is_valid() and data_output_formset.is_valid() \ and new_data_input_formset.is_valid() and new_data_output_formset.is_valid(): coordinator = coordinator_form.save() dataset_formset.save() data_input_formset.save() data_output_formset.save() new_data_input_formset.save() new_data_output_formset.save() request.info(_('Coordinator saved!')) return redirect( reverse('oozie:edit_coordinator', kwargs={'coordinator': coordinator.id})) else: coordinator_form = CoordinatorForm(instance=coordinator, user=request.user) dataset_formset = DatasetFormSet(instance=coordinator) data_input_formset = DataInputFormSet(instance=coordinator) data_output_formset = DataOutputFormSet(instance=coordinator) new_data_input_formset = NewDataInputFormSet( queryset=DataInput.objects.none(), instance=coordinator, prefix='input') new_data_output_formset = NewDataOutputFormSet( queryset=DataOutput.objects.none(), instance=coordinator, prefix='output') return render( 'editor/edit_coordinator.mako', request, { 'coordinator': coordinator, 'coordinator_form': coordinator_form, 'dataset_formset': dataset_formset, 'data_input_formset': data_input_formset, 'data_output_formset': data_output_formset, 'dataset_form': dataset_form, 'new_data_input_formset': new_data_input_formset, 'new_data_output_formset': new_data_output_formset, 'history': history, 'parameters': extract_field_data(coordinator_form['parameters']) })
def get_formset(self, request, obj=None, **kwargs): formset = super(TrackInline, self).get_formset(request, obj, **kwargs) if request.method == 'GET': formset.__init__ = curry(formset.__init__, initial=self.initial) return formset
def get_formset(self, request, obj=None, **kwargs): formset = super(RequestProvidingModelAdminMixin, self).\ get_formset(request, obj, **kwargs) formset.form.__init__ = curry(formset.form.__init__, request=request) return formset
def get_manipulator_field_objs(self): choices = self.get_choices_default() return [curry(oldforms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
def __init__(self, request): for name in self.API: api_fn = getattr(messages.api, name) setattr(self, name, curry(api_fn, request))
def request(self, **request): """ The master request method. Composes the environment dictionary and passes to the handler, returning the result of the handler. Assumes defaults for the query environment, which can be overridden using the arguments to the request. """ environ = self._base_environ(**request) # Curry a data dictionary into an instance of the template renderer # callback function. data = {} on_template_render = curry(store_rendered_templates, data) signal_uid = "template-render-%s" % id(request) signals.template_rendered.connect(on_template_render, dispatch_uid=signal_uid) # Capture exceptions created by the handler. exception_uid = "request-exception-%s" % id(request) got_request_exception.connect(self.store_exc_info, dispatch_uid=exception_uid) try: try: response = self.handler(environ) except TemplateDoesNotExist as e: # If the view raises an exception, Django will attempt to show # the 500.html template. If that template is not available, # we should ignore the error in favor of re-raising the # underlying exception that caused the 500 error. Any other # template found to be missing during view error handling # should be reported as-is. if e.args != ('500.html',): raise # Look for a signalled exception, clear the current context # exception data, then re-raise the signalled exception. # Also make sure that the signalled exception is cleared from # the local cache! if self.exc_info: exc_info = self.exc_info self.exc_info = None six.reraise(*exc_info) # Save the client and request that stimulated the response. response.client = self response.request = request # Add any rendered template detail to the response. response.templates = data.get("templates", []) response.context = data.get("context") response.json = curry(self._parse_json, response) # Attach the ResolverMatch instance to the response response.resolver_match = SimpleLazyObject( lambda: urlresolvers.resolve(request['PATH_INFO'])) # Flatten a single context. Not really necessary anymore thanks to # the __getattr__ flattening in ContextList, but has some edge-case # backwards-compatibility implications. if response.context and len(response.context) == 1: response.context = response.context[0] # Update persistent cookie data. if response.cookies: self.cookies.update(response.cookies) return response finally: signals.template_rendered.disconnect(dispatch_uid=signal_uid) got_request_exception.disconnect(dispatch_uid=exception_uid)
def make_foreign_order_accessors(field, model, cls): setattr(field.rel.to, 'get_%s_order' % cls.__name__.lower(), curry(method_get_order, cls)) setattr(field.rel.to, 'set_%s_order' % cls.__name__.lower(), curry(method_set_order, cls))
def get_manipulator_field_objs(self): if self.rel.raw_id_admin: return [forms.RawIdAdminField] else: choices = self.get_choices_default() return [curry(forms.CheckboxSelectMultipleField, choices=choices)]
from django.conf import settings from django.conf.urls.static import static # from djrill import DjrillAdminSite # admin.site = DjrillAdminSite() admin.autodiscover() #dajaxice_autodiscover() #from yawdadmin import admin_site urlpatterns = patterns( '', #url(r'^admin_tools/', include('admin_tools.urls')), url(r'^admin/', include(admin.site.urls)), url(r'^', include('apps.account_system.urls')), url(r'^', include('apps.establishment_system.urls')), url(r'^', include('apps.recommender_system.urls')), url(r'^', include('apps.main.urls')), url(r'^autocomplete/', include('autocomplete_light.urls')), ) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) urlpatterns += staticfiles_urlpatterns() if 'grappelli' in settings.INSTALLED_APPS: urlpatterns += patterns('', url(r'^grappelli/', include('grappelli.urls'))) from django.utils.functional import curry from django.views.defaults import page_not_found, server_error, permission_denied #handler404 = "apps.main.views.error404" handler500 = curry(server_error, template_name='main/500.html') handler404 = curry(page_not_found, template_name='main/404.html') #handler403 = curry(permission_denied, template_name='main/403.html')
def get_comparison(self): comparator_class = self.get_comparison_class() if comparator_class: return [curry(comparator_class, self.db_field)] return []
def add_accessor_methods(self, *args, **kwargs): for contact_type, name in CONTACT_TYPES: setattr(self, '%s_relations' % contact_type, curry(self._get_TYPE_relations, contact_type=contact_type))
def _get_render_func(dotted_path, **kwargs): # Don't coerce to unicode on python 2 (module, func) = dotted_path.rsplit(str('.'), 1) func = getattr(__import__(module, {}, {}, [func]), func) return curry(func, **kwargs)
# Check that the deserialized object contains data in only the serialized fields. self.assertEqual(result.object.field1, 'first') self.assertEqual(result.object.field2, '') self.assertEqual(result.object.field3, 'third') def streamTest(format, self): obj = ComplexModel(field1='first', field2='second', field3='third') obj.save_base(raw=True) # Serialize the test database to a stream stream = StringIO() serializers.serialize(format, [obj], indent=2, stream=stream) # Serialize normally for a comparison string_data = serializers.serialize(format, [obj], indent=2) # Check that the two are the same self.assertEqual(string_data, stream.getvalue()) stream.close() for format in serializers.get_serializer_formats(): setattr(SerializerTests, 'test_' + format + '_serializer', curry(serializerTest, format)) setattr(SerializerTests, 'test_' + format + '_serializer_fields', curry(fieldsTest, format)) if format != 'python': setattr(SerializerTests, 'test_' + format + '_serializer_stream', curry(streamTest, format))
"""shortly URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/2.0/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.urls import include, path 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) """ from django.contrib import admin from django.urls import path from django.views.defaults import page_not_found from django.utils.functional import curry from appshortly import views handler404 = curry(page_not_found, template_name='appshortly/404.html') urlpatterns = [ path('admin/', admin.site.urls), path('', views.index), path('<int:url_id>', views.detail_url), path('<int:url_id>/detail', views.view_url), path('create_short_url', views.create_new_url), ]
def edit(request, id, form_class=StudyGroupForm, meta_form_class=MetaForm, category_form_class=CategoryForm, template_name="studygroups/edit.html"): study_group = get_object_or_404(StudyGroup, pk=id) if not has_perm(request.user, 'studygroups.change_studygroup', study_group): raise Http403 content_type = get_object_or_404(ContentType, app_label='studygroups', model='studygroup') #setup categories category = Category.objects.get_for_object(study_group, 'category') sub_category = Category.objects.get_for_object(study_group, 'sub_category') initial_category_form_data = { 'app_label': 'studygroups', 'model': 'studygroup', 'pk': study_group.pk, 'category': getattr(category, 'name', '0'), 'sub_category': getattr(sub_category, 'name', '0') } OfficerFormSet = inlineformset_factory(StudyGroup, Officer, form=OfficerForm, extra=1) OfficerFormSet.form = staticmethod( curry(OfficerForm, study_group_group=study_group.group)) if request.method == "POST": form = form_class(request.POST, request.FILES, instance=study_group, user=request.user) metaform = meta_form_class(request.POST, instance=study_group.meta, prefix='meta') categoryform = category_form_class(content_type, request.POST, initial=initial_category_form_data, prefix='category') formset = OfficerFormSet(request.POST, instance=study_group, prefix="officers") if form.is_valid() and metaform.is_valid() and categoryform.is_valid( ) and formset.is_valid(): study_group = form.save(commit=False) # update all permissions and save the model study_group = update_perms_and_save(request, form, study_group) #save meta meta = metaform.save() study_group.meta = meta formset.save() ## update the category of the studygroup category_removed = False category = categoryform.cleaned_data['category'] if category != '0': Category.objects.update(study_group, category, 'category') else: # remove category_removed = True Category.objects.remove(study_group, 'category') Category.objects.remove(study_group, 'sub_category') if not category_removed: # update the sub category of the studygroup sub_category = categoryform.cleaned_data['sub_category'] if sub_category != '0': Category.objects.update(study_group, sub_category, 'sub_category') else: # remove Category.objects.remove(study_group, 'sub_category') #save relationships study_group.save() EventLog.objects.log(instance=study_group) messages.add_message(request, messages.SUCCESS, 'Successfully updated %s' % study_group) if not request.user.profile.is_superuser: # send notification to administrators recipients = get_notice_recipients('module', 'studygroups', 'studygrouprecipients') if recipients: if notification: extra_context = { 'object': study_group, 'request': request, } notification.send_emails(recipients, 'study_group_edited', extra_context) return HttpResponseRedirect( reverse('studygroups.detail', args=[study_group.slug])) else: form = form_class(instance=study_group, user=request.user) metaform = meta_form_class(instance=study_group.meta, prefix='meta') categoryform = category_form_class(content_type, initial=initial_category_form_data, prefix='category') formset = OfficerFormSet(instance=study_group, prefix="officers") #formset.form = staticmethod(curry(OfficerForm, study_group_group=study_group.group)) return render_to_resp(request=request, template_name=template_name, context={ 'study_group': study_group, 'form': form, 'metaform': metaform, 'categoryform': categoryform, 'formset': formset, })