def test_render_nonimage(self):
"""
``ImageWidget`` renders the file input only, if given a non-image.
"""
widget = ImageWidget()
html = widget.render('fieldname', FieldFile(None, FileField(), 'something.txt'))
self.assertHTMLEqual(html, '<input type="file" name="fieldname" />')
def test_render_nonimage(self):
"""
``ImageWidget`` renders the file input only, if given a non-image.
"""
widget = ImageWidget()
html = widget.render('fieldname', FieldFile(None, FileField(), 'something.txt'))
self.assertHTMLEqual(html, '<input type="file" name="fieldname" value="something.txt" />')
def test_custom_template(self):
"""
``ImageWidget`` respects a custom template.
"""
widget = ImageWidget(template='<div>%(image)s</div>'
'<div>%(input)s</div>')
html = widget.render('fieldname', 'tiny.png')
self.failUnless(html.startswith('<div><img src="/media/tiny'))
def test_custom_template(self):
"""
``ImageWidget`` respects a custom template.
"""
widget = ImageWidget(template='<div>%(image)s</div>'
'<div>%(input)s</div>')
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue(html.startswith('<div><img'))
def test_custom_template(self):
"""
``ImageWidget`` respects a custom template.
"""
widget = ImageWidget(template='<div>%(image)s</div>'
'<div>%(input)s</div>')
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue(html.startswith('<div><img'))
def test_render(self):
"""
``ImageWidget`` renders the file input and the image thumb.
"""
widget = ImageWidget()
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
# test only this much of the html, because the remainder will
# vary depending on whether we have sorl-thumbnail
self.assertTrue('<img' in html)
self.assertTrue('/media/tiny' in html)
def test_render(self):
"""
``ImageWidget`` renders the file input and the image thumb.
"""
widget = ImageWidget()
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
# test only this much of the html, because the remainder will
# vary depending on whether we have sorl-thumbnail
self.assertTrue('<img' in html)
self.assertTrue('/media/tiny' in html)
def test_render(self):
"""
``ImageWidget`` renders the file input and the image thumb.
"""
widget = ImageWidget()
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
# test only this much of the html, because the remainder will
# vary depending on whether we have sorl-thumbnail
self.assertTrue(html.startswith(
'<input type="file" name="fieldname" value="tiny.png" />'
'<br /><img src="/media/tiny'), html)
class Meta:
model = Eestecer
fieldsets = [
('Name', {
'fields':
['first_name', 'middle_name', 'last_name', 'second_last_name']
}),
('Additional Information', {
'fields': [
'gender', 'date_of_birth', 'show_date_of_birth', 'email',
'thumbnail', 'field_of_study', 'curriculum_vitae'
]
}),
('Contact Information', {
'fields': ['hangouts', 'mobile', 'description', 'skype']
}),
('Event Information', {
'fields': [
'tshirt_size', 'passport_number', 'food_preferences',
'allergies'
]
}),
('Administrative Information', {
'fields': ['receive_eestec_active']
}),
]
widgets = {
'date_of_birth':
TextInput(attrs={'class': 'date'}),
'description':
EESTECEditor(include_jquery=False),
'thumbnail':
ImageWidget(template='<span>%(image)s<br />%(input)s</span>'),
}
def test_custom_file_widget(self):
"""
``ClearableFileInput`` respects its ``file_widget`` argument.
"""
widget = ClearableFileInput(file_widget=ImageWidget())
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue('<img' in html)
class Meta:
model = Meal
exclude = [
'cook',
]
widgets = {
'image': ImageWidget(),
}
class Meta:
model = Ad
widgets = {
'start': DateWidget(usel10n=True, bootstrap_version=3),
'end': DateWidget(usel10n=True, bootstrap_version=3),
'image': ImageWidget()
}
exclude = ['id']
def test_custom_file_field_widget_used(self):
"""
If we pass in our own ``file_field`` its widget is used for
the internal file field.
"""
widget = ImageWidget()
file_field = forms.ImageField(widget=widget)
field = ClearableFileField(file_field=file_field)
self.assertTrue(field.fields[0].widget is widget)
class Meta:
model = Job
fields = [
'title', 'url', 'organization', 'image', 'categories', 'approved',
'include_in_newsletter', 'pub_date'
]
widgets = {
'pub_date': DateTimeWidget(usel10n=True, bootstrap_version=3),
'image': ImageWidget(),
}
labels = job_field_labels
help_texts = job_help_texts
class EestecerChangeForm(UserChangeForm):
"""A form for updating users. Includes all the fields on
the user, but replaces the password field with admin's
password hash display field.
"""
thumbnail = ImageField(widget=ImageWidget())
def __init__(self, *args, **kargs):
super(EestecerChangeForm, self).__init__(*args, **kargs)
del self.fields['username']
class Meta:
model = Eestecer
def render(self, name, value, attrs=None):
"""
Wrapper to super class render, providing a "no image" thumbnail when there's no picture,
and getting the thumbnail image path if there's.
"""
if not value:
try:
value = settings.DAG_NO_IMAGE[self.photo_size]
except AttributeError:
value = ""
else:
if isinstance(value, long):
try:
value = Photo.objects.get(pk=value).image
except Photo.DoesNotExist:
value = None
if value:
path_dir = os.path.dirname(value.name)
extension = os.path.basename(value.name).split(".")[-1]
filename = smart_unicode(os.path.basename(value.name).replace(".%s" % extension, ""))
value.name = "%s/cache/%s_%s.%s" % (path_dir, filename, self.photo_size, extension)
self.template = self.template % {"photo_label": _("Photo")}
return ImageWidget.render(self, name, value, attrs=attrs)
class EventImageInline(InlineFormSet):
model = EventImage
form_class = modelform_factory(EventImage,
widgets={'image': ImageWidget()})
class EventImages(EventMixin, DialogFormMixin, UpdateWithInlinesView):
model = Event
form_class = modelform_factory(Event, fields=('thumbnail',),
widgets={'thumbnail': ImageWidget()})
inlines = [EventImageInline]
class Meta:
model = Image
exclude = ('key', 'uploaded_by', 'date_created', 'date_updated')
widgets = {
'image': ImageWidget(),
}
def __init__(self, photo_size, *args, **kwargs):
self.photo_size = photo_size
ImageWidget.__init__(self, template=self.template, *args, **kwargs)
class Meta:
model = Team
fields = ('thumbnail', )
widgets = {'thumbnail': ImageWidget()}
class LargeImagePreviewInChangeForm(object):
formfield_overrides = {
ImageField: {'widget': ImageWidget()},
}
class Meta:
model = MemberImage
widgets = {'image': ImageWidget()}
class EditFormSocio(RegistrationForm):
first_name = forms.CharField(max_length=50, label=_(u'Nome'))
last_name = forms.CharField(max_length=50, label=_(u'Cognome'))
born_date = forms.DateField(input_formats=["%d/%m/%Y"],
label=_(u'Data di Nascita'))
born_place = forms.CharField(max_length=50, label=_(u'Luogo di Nascita'))
doc_type = forms.ChoiceField(choices=DOCUMENT_TYPES, label=_(u'Documento'))
doc_id = forms.CharField(max_length=20, label=_(u'N documento'))
username = forms.RegexField(
regex=r'^[\w.@+-]+$',
max_length=30,
widget=forms.TextInput(),
label=_("Username/Nickname"),
error_messages={
'invalid':
_("Questo campo puo' contenere solo lettere, numeri e questi caratteri @/./+/-/_ "
)
})
password1 = forms.CharField(widget=forms.PasswordInput(render_value=False),
label=_("Password"),
required=False)
password2 = forms.CharField(widget=forms.PasswordInput(render_value=False),
label=_("Password (di nuovo)"),
required=False)
photo = forms.ImageField(required=False,
label=_(u'Foto'),
widget=ImageWidget(
width=50,
height=50,
template='%(input)s<br />%(image)s'))
how_hear = forms.CharField(max_length=500,
widget=forms.Textarea,
label=_(u'Come ci hai conosciuto?'),
required=False)
salutatore = forms.CharField(
max_length=500,
widget=forms.Textarea,
label=_(u'Saluto personalizzato sul salutatore'),
required=False)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
self.activation_key = kwargs.pop('activation_key', None)
self.activating_user = kwargs.pop('activating_user', None)
super(EditFormSocio, self).__init__(*args, **kwargs)
def clean(self):
data = self.cleaned_data
if 'photo' in data and data['photo']:
image = self.request.FILES['photo']
if image.size > MAX_PHOTO_SIZE:
raise forms.ValidationError(
_("La foto che hai immesso e' troppo grande"))
if self.activation_key:
try:
user = RegistrationProfile.objects.get(
activation_key=self.activation_key).user
except RegistrationProfile.DoesNotExist:
user = None
else:
user = self.request.user
if not user: #give error
return render_to_response('registration/activate.html', {},
context_instance=RequestContext(request))
has_password = user.is_authenticated() and user.has_usable_password()
if not has_password:
if ('password1' not in self.cleaned_data
or len(self.cleaned_data['password1']) <= 0) or (
'password2' not in self.cleaned_data
or len(self.cleaned_data['password2']) <= 0):
raise forms.ValidationError(
_("Non hai nessuna password impostata. Imposta una password per poterti autenticare."
))
if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data:
if self.cleaned_data['password1'] != self.cleaned_data['password2']:
raise forms.ValidationError(
_("Le password non corrispondono."))
return self.cleaned_data
def clean_username(self):
if self.activating_user:
user = self.activating_user
if user.username == self.cleaned_data['username']:
return self.cleaned_data['username']
# if change username and has activation key, or if just change username:
if self.request.user.username != self.cleaned_data['username']:
existing = User.objects.filter(
username__iexact=self.cleaned_data['username'])
if existing.exists():
raise forms.ValidationError(
_("Questo username e' stato gia' preso da un altro utente."
))
return self.cleaned_data['username']
def do_save(self, user):
if user:
user = user
else:
user = self.request.user
profile = user.get_profile()
data = self.cleaned_data
user.first_name = data['first_name']
user.last_name = data['last_name']
user.email = data['email']
user.username = data['username']
if data['password1'] and len(data['password1']) > 0:
user.set_password(data['password1'])
profile.born_date, profile.born_place = data['born_date'], data[
'born_place']
profile.doc_type, profile.doc_id = data['doc_type'], data['doc_id']
if 'how_hear' in data and len(data['how_hear']):
profile.how_hear = data['how_hear']
if 'salutatore' in data and len(data['salutatore']):
profile.salutatore = data['salutatore']
if 'photo' in data and data['photo']:
image = self.request.FILES['photo']
profile.photo.save(image.name, image)
profile.user = user
profile.save()
user.save()
from ....forms import PostSubmitForm, PostUpdateForm
from ..models import Job
job_field_labels = {
'image': 'Institution Logo (10Mb Limit)',
'url': 'URL',
'categories': 'Categories (choose up to 3)'
}
job_help_texts = {
'url': 'Provide a full URL, e.g., "http://www.example.com/page.html"',
'pub_date': 'Date job originally appeared on website'
}
field_widgets = {'image': ImageWidget(attrs={'required': 'required'})}
class JobSubmitForm(PostSubmitForm):
class Meta:
model = Job
fields = ['title', 'url', 'organization', 'image', 'categories']
labels = job_field_labels
help_texts = job_help_texts
widgets = field_widgets
class JobUpdateForm(PostUpdateForm):
class Meta:
model = Job
fields = [
