class Meta(object):
model = DigitalObject
widgets = {
'related_production':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=ProductionLookup, attrs={'size': '100'}),
'related_festival':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=FestivalOccurrenceLookup, attrs={'size': '100'}),
'related_venue':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=LocationLookup, attrs={'size': '100'}),
'related_work':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=WorkRecordLookup, attrs={'size': '100'}),
'related_award':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=AwardCandidateLookup, attrs={'size': '100'}),
'collection':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CollectionLookup, attrs={'size': '100'}),
'object_creator':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
'phys_obj_city':
selectable_forms.AutoCompleteSelectWidget(lookup_class=CityLookup,
attrs={'size': '100'}),
}
class Meta(object):
model = CastMember
widgets = {
'person':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
'role':
selectable_forms.AutoCompleteSelectWidget(lookup_class=RoleLookup,
attrs={'size': '60'}),
}
class Meta(object):
model = Location
widgets = {
'city':
selectable_forms.AutoCompleteSelectWidget(lookup_class=CityLookup,
attrs={'size': '100'}),
'country':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CountryLookup, attrs={'size': '100'}),
'photo':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=DigitalObjectLookup, attrs={'size': '100'}),
}
class Meta(object):
model = Encuesta
fields = '__all__'
widgets = {
'entrevistado':
selectable.AutoCompleteSelectWidget(lookup_class=ProductorLookup),
}
class Meta:
model = Profile
fields = ('__all__')
widgets = {
'user':
selectable.AutoCompleteSelectWidget(lookup_class=UserLookup),
}
class Meta(object):
model = Role
widgets = {
'source_text':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=WorkRecordLookup, attrs={'size': '100'}),
}
class Meta(object):
model = RelatedWork
widgets = {
'second_work':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=WorkRecordLookup, attrs={'size': '100'}),
}
class VenueForm(forms.ModelForm):
name = forms.CharField(required=True, max_length=255, min_length=3)
city = forms.CharField(widget=selectable.AutoCompleteSelectWidget(
CityLookup, allow_new=True),
required=False)
city_identifier = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
location = forms.Field(widget=LocationWidget(), required=False)
class Meta:
model = Venue
fields = ['name', 'street', 'street_number', 'location']
def __init__(self, **kwargs):
if 'instance' in kwargs and kwargs['instance']:
initial = kwargs['initial'] if 'initial' in kwargs else {}
if 'city_identifier' not in initial:
initial['city_identifier'] = kwargs['instance'].city.id
if 'city' not in initial:
initial['city'] = kwargs['instance'].city
kwargs['initial'] = initial
super(VenueForm, self).__init__(**kwargs)
class Meta(object):
model = RelatedCreator
widgets = {
'second_creator':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '60'}),
}
class Meta(object):
model = Stage
widgets = {
'venue':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=LocationLookup, attrs={'size': '100'}),
}
class Meta(object):
model = DigitalObject_Related_Creator
widgets = {
'creator':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
}
class Meta(object):
model = City
widgets = {
'country':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CountryLookup, attrs={'size': '100'}),
}
class Meta(object):
model = DirectingMember
widgets = {
'person':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'})
}
class Meta(object):
model = WorkRecordCreator
widgets = {
'creator':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
}
class Meta(object):
model = FestivalParticipant
widgets = {
'participant':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
}
class Meta(object):
model = Repository
widgets = {
'location':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=LocationLookup, attrs={'size': '100'})
}
class Meta(object):
model = Team
exclude = (
'request_text',
'approved',
)
widgets = {
'user':
selectable.AutoCompleteSelectWidget(lookup_class=UserLookup)
}
class Meta(object):
model = WorkRecord
widgets = {
'digital_copy':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=DigitalObjectLookup, attrs={'size': '60'}),
'primary_publications':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size': '100'}),
'secondary_publications':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size': '100'}),
}
class Meta(object):
model = Production
widgets = \
{'source_work':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=WorkRecordLookup, attrs={'size':'100'}),
'venue':selectable_forms.AutoCompleteSelectWidget(
lookup_class=LocationLookup, attrs={'size':'100'}),
'primary_publications': \
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),
'secondary_publications': \
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),}
class Meta(object):
model = Creator
widgets = {
'birth_city': selectable_forms.AutoCompleteSelectWidget(
lookup_class=CityLookup,
attrs={'size':'60'}),
'death_city': selectable_forms.AutoCompleteSelectWidget(
lookup_class=CityLookup,
attrs={'size':'60'}),
'nationality': selectable_forms.AutoCompleteSelectWidget(
lookup_class=CountryLookup,
attrs={'size':'60'}),
'headquarter_city': selectable_forms.AutoCompleteSelectWidget(
lookup_class=CityLookup,
attrs={'size':'60'}),
'photo': selectable_forms.AutoCompleteSelectWidget(
lookup_class=DigitalObjectLookup,
attrs={'size':'60'}),
'primary_publications': \
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),
'secondary_publications':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),}
class Meta(object):
model = FestivalOccurrence
widgets = {
'festival_series':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=FestivalLookup, attrs={'size': '100'}),
'venue':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=LocationLookup, attrs={'size': '100'}),
'productions':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=ProductionLookup, attrs={'size': '100'}),
'primary_publications':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size': '100'}),
}
class Meta(object):
model = AwardCandidate
widgets = {
'award':
selectable_forms.AutoCompleteSelectWidget(lookup_class=AwardLookup,
attrs={'size': '100'}),
'recipient':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=CreatorLookup, attrs={'size': '100'}),
'production':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=ProductionLookup, attrs={'size': '100'}),
'place':
selectable_forms.AutoCompleteSelectWidget(lookup_class=CityLookup,
attrs={'size': '100'}),
'festival':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=FestivalLookup, attrs={'size': '100'}),
'work_record':
selectable_forms.AutoCompleteSelectWidget(
lookup_class=WorkRecordLookup, attrs={'size': '100'}),
}
class CellSampleForm( SampleForm ):
"""Customized Form for CellSample add / change"""
cellCategory = forms.ModelChoiceField(label='In Species',
queryset=M.CellComponentType.objects.filter(subTypeOf=None),
required=False,
empty_label=None,
initial=T.ccEcoli)
cellType = forms.ModelChoiceField(label='Strain',
queryset=M.CellComponentType.objects.exclude(subTypeOf=None),
required=False,
empty_label=None,
initial=T.ccMach1)
plasmid = sforms.AutoCompleteSelectField(label='Plasmid',
lookup_class=L.PlasmidLookup,
required=False,
help_text='start typing ID or name of plasmid...',
widget=sforms.AutoCompleteSelectWidget(lookup_class=L.PlasmidLookup,
allow_new=False,
attrs={'size':35}),)
def __init__(self, *args, **kwargs):
super(CellSampleForm, self).__init__(*args, **kwargs)
## keep constraint on DB level but allow user to specify via plasmid+type
self.fields['cell'].required = False
o = kwargs.get('instance', None)
if o:
self.fields['cellCategory'].initial = o.cell.componentType.category()
self.fields['cellType'].initial = o.cell.componentType
self.fields['plasmid'].initial = o.cell.plasmid
def clean(self):
"""
Verify that cell or plasmid + strain are given, create new cell if needed.
"""
super(CellSampleForm, self).clean()
data = self.cleaned_data
cell = data.get('cell', None)
plasmid = data.get('plasmid', None)
ctype = data.get('cellType', None)
if not cell and not (plasmid and ctype):
msg = u'Please specify either an existing cell or a plasmid and strain.'
self._errors['cell'] = self.error_class([msg])
try:
del data['cell'] ## needed to really stop form saving
except:
pass
elif plasmid and cell:
if plasmid != cell.plasmid:
msg = u'Given plasmid does not match selected cell record. Remove one or the other.'
self._errors['plasmid'] = self.error_class([msg])
del data['plasmid']
if ctype != cell.componentType:
msg = u'Given strain does not match selected cell record. Clear either plasmid or cell selection.'
self._errors['cellType'] = self.error_class([msg])
del data['cellType']
if (not cell) and plasmid:
existing = M.CellComponent.objects.filter(plasmid=plasmid,
componentType=ctype)
if existing.count():
data['cell'] = existing.all()[0]
messages.success(self.request,
'Attached existing cell record %s (%s) to sample.'\
% (data['cell'].displayId, data['cell'].name))
else:
newcell = M.CellComponent(componentType=ctype,
plasmid=plasmid,
displayId=M.CellComponent.nextAvailableId(self.request.user),
registeredBy = self.request.user,
registeredAt = datetime.datetime.now(),
name = plasmid.name + '@' + ctype.name,
)
newcell.save()
## Many2Many relationships can only be created after save
newcell.authors = [self.request.user]
newcell.projects = plasmid.projects.all()
newcell.save()
data['cell'] = newcell
messages.success(self.request,
'Created new cell record %s (%s)' %\
(newcell.displayId, newcell.name))
return data
class Meta:
model = M.CellSample
widgets = getSampleWidgets( \
{'cell': sforms.AutoComboboxSelectWidget(lookup_class=L.SampleCellLookup,
allow_new=False,
attrs={'size':35}),
})
class VenueAccountForm(forms.ModelForm):
# There will be three modes, how we will detect wich venue user choose
# SUGGEST - when user can not found venue in google autocomplete he can suggest new venue
# GOOGLE - user can choose venue with help of google autocomplete widget
# EXIST - user can choose also from venues that already exist on cityfusion
linking_venue_mode = forms.CharField(required=True,
widget=forms.widgets.HiddenInput())
place = JSONCharField(widget=GeoCompleteWidget(), required=False)
location = forms.Field(widget=LocationWidget(), required=False)
venue_identifier = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
venue_name = forms.CharField(required=False, max_length=50, min_length=3)
street = forms.CharField(required=False)
street_number = forms.CharField(required=False)
city = forms.CharField(widget=selectable.AutoCompleteSelectWidget(
CityLookup, allow_new=True),
required=False)
city_identifier = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
picture_src = forms.CharField(widget=AjaxCropWidget(), required=False)
types = forms.ModelMultipleChoiceField(
widget=forms.CheckboxSelectMultiple,
queryset=VenueType.active_types.all(),
required=False)
phone = CAPhoneNumberField(required=False)
fax = CAPhoneNumberField(required=False)
about = RichTextFormField(required=False)
tags = TagField(widget=VenueTagAutoSuggest(), required=False)
social_links = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
class Meta:
model = VenueAccount
fields = ('phone', 'fax', 'email', 'site', 'facebook', 'myspace',
'twitter', 'about', 'cropping', 'types', 'tags')
def clean_tags(self):
tags = self.cleaned_data['tags']
if len(tags) > 10:
raise forms.ValidationError(
"I'm sorry, but 10 tags is the maximum amount per event.")
return tags
def clean_social_links(self):
if not self.cleaned_data["social_links"]:
return []
social_links = json.loads(
self.cleaned_data["social_links"])["social_links"]
for social_link in social_links:
if not social_link["title"]:
raise forms.ValidationError("Title is required")
if not social_link["url"]:
raise forms.ValidationError("Url is required")
validators.URLValidator(message="Enter a valid URL.")(
social_link["url"])
return social_links
def clean(self):
cleaned_data = self.cleaned_data
if "linking_venue_mode" in cleaned_data:
linking_venue_mode = cleaned_data["linking_venue_mode"]
else:
linking_venue_mode = None
if not linking_venue_mode:
raise forms.ValidationError(u'Please specify venue')
if linking_venue_mode == "SUGGEST":
if not cleaned_data["venue_name"]:
raise forms.ValidationError(u'Please specify venue name')
if not cleaned_data["city_identifier"]:
self.city_required = True
raise forms.ValidationError(u'Pleace specify city')
if not cleaned_data["location"]:
raise forms.ValidationError(
u'Please specify location on the map')
if linking_venue_mode == "GOOGLE":
place = cleaned_data["place"]
if not place["city"]:
raise forms.ValidationError(
u'Please select at least a city or town name')
if not place["venue"] or \
not place["latitude"] or \
not place["longtitude"]:
raise forms.ValidationError(
u'Location that you choose is invalid, please, choose another one'
)
if linking_venue_mode == "EXIST":
pass
return cleaned_data
def save(self, *args, **kwargs):
venue_account = super(VenueAccountForm, self).save(*args, **kwargs)
venue_account.venueaccountsociallink_set.all().delete()
social_links = self.cleaned_data["social_links"]
for social_link in social_links:
VenueAccountSocialLink.objects.create(title=social_link["title"],
link=social_link["url"],
venue_account=venue_account)
return venue_account
class Meta(object):
model = Finca
widgets = {
'nombre_productor':
selectable.AutoCompleteSelectWidget(lookup_class=ProductorLookup),
}
class Meta(object):
model = Lead
widgets = {
'lead':
selectable.AutoCompleteSelectWidget(lookup_class=UserLookup)
}
class EditEventForm(forms.ModelForm):
class Meta:
model = Event
exclude = ('owner', 'authentication_key', 'slug', 'email',
'facebook_event')
# There will be four modes, how we will detect wich venue user choose
# SUGGEST - when user can not found venue in google autocomplete he can suggest new venue
# GOOGLE - user can choose venue with help of google autocomplete widget
# OWNER - when user choose venue as owner of event, we can use this venue by default
# EXIST - user can choose also from venues that already exist on cityfusion
linking_venue_mode = forms.CharField(required=True,
widget=forms.widgets.HiddenInput())
place = JSONCharField(widget=GeoCompleteWidget(), required=False)
location = forms.Field(widget=LocationWidget(), required=False)
venue_identifier = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
venue_name = forms.CharField(required=False)
street = forms.CharField(required=False)
city = forms.CharField(widget=selectable.AutoCompleteSelectWidget(
CityLookup, allow_new=True),
required=False)
city_identifier = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
when = forms.CharField(widget=WhenWidget(), required=True)
when_json = forms.CharField(required=True,
widget=forms.widgets.HiddenInput())
occurrences_json = forms.CharField(required=False,
widget=forms.widgets.HiddenInput())
# SINGLE
# MULTIDAY
event_type = forms.CharField(required=True,
widget=forms.widgets.HiddenInput())
description = RichTextFormField(required=False)
description_json = forms.CharField(required=True,
widget=forms.widgets.HiddenInput())
attachments = forms.CharField(widget=AttachmentsWidget(), required=False)
price = forms.CharField(required=False, initial="$")
images = forms.CharField(widget=EventImagesWidget(), required=False)
website = forms.URLField(required=False)
tickets = forms.CharField(required=False)
def __init__(self, account, *args, **kwargs):
self.city_required = False
created_by_admin = kwargs.pop('by_admin', False)
super(EditEventForm, self).__init__(*args, **kwargs)
self.fields['venue_account_owner'].widget = ChooseUserContextWidget(
account, by_admin=created_by_admin)
if 'email' in self.fields:
self.fields['email'].widget = HTML5EmailInput(
attrs={'class': 'text wide'})
self.fields['email'].label = _(u'Email Address')
self.fields['name'].widget.attrs['tabindex'] = 1
self.fields['name'].error_messages[
'required'] = 'Event name is required'
self.fields['name'].label = _(u'Event Name')
self.fields['linking_venue_mode'].error_messages[
'required'] = 'Your event cannot miss a location'
self.fields['place'].error_messages[
'required'] = 'Your event cannot miss a location'
self.fields['place'].label = _(u'Location')
self.fields['place'].widget.attrs['tabindex'] = 2
# Suggest venue popup
self.fields['city'].error_messages[
'required'] = 'Your event cannot miss a city'
self.fields['city'].label = _(u'City')
self.fields['when'].widget.attrs['readonly'] = True
self.fields['when'].widget.attrs['placeholder'] = "Click to select"
self.fields['when'].error_messages[
'required'] = 'Please choose at least one date'
self.fields['when_json'].error_messages[
'required'] = 'Please choose at least one date'
self.fields['price'].widget.attrs['tabindex'] = 3
self.fields['description'].widget = forms.widgets.Textarea(
attrs={
'class': 'textarea',
'tabindex': 4
})
self.fields['website'].widget.attrs['tabindex'] = 5
self.fields['website'].error_messages[
'invalid'] = 'Enter a valid website url'
self.fields['tickets'].widget.attrs['tabindex'] = 6
self.fields['tags'].error_messages[
'required'] = 'Please enter at least one tag'
self.fields['tags'].widget.attrs['tabindex'] = 7
def clean(self):
cleaned_data = self.cleaned_data
if 'tags' in cleaned_data:
cleaned_data['tags'] = map(string.capwords, cleaned_data['tags'])
if "linking_venue_mode" in cleaned_data:
linking_venue_mode = cleaned_data["linking_venue_mode"]
else:
linking_venue_mode = None
if not linking_venue_mode:
raise forms.ValidationError(u'Please specify venue')
if linking_venue_mode == "SUGGEST":
if not cleaned_data["venue_name"]:
raise forms.ValidationError(u'Please specify venue name')
if not cleaned_data["city_identifier"]:
self.city_required = True
raise forms.ValidationError(u'Pleace specify city')
if not cleaned_data["location"]:
raise forms.ValidationError(
u'Please specify location on the map')
if linking_venue_mode == "GOOGLE":
place = cleaned_data["place"]
if not place["city"]:
raise forms.ValidationError(
u'Please select at least a city or town name')
if not place["venue"] or \
not place["latitude"] or \
not place["longtitude"]:
raise forms.ValidationError(
u'Location that you choose is invalid, please, choose another one'
)
if linking_venue_mode == "OWNER":
pass
if linking_venue_mode == "EXIST":
pass
return cleaned_data
def clean_tags(self):
tags = self.cleaned_data['tags']
if len(tags) > 10:
raise forms.ValidationError(
"I'm sorry, but 10 tags is the maximum amount per event.")
return tags
def clean_when_json(self):
when_json = json.loads(self.cleaned_data["when_json"])
for year, months in when_json.iteritems():
for month, days in months.iteritems():
for day, times in days.iteritems():
try:
dateparser.parse(times["start"])
except:
raise forms.ValidationError(
"%s is not valid start time. Please use right format"
% times["start"])
try:
dateparser.parse(times["end"])
except:
raise forms.ValidationError(
"%s is not valid end time. Please use right format"
% times["end"])
