def fields(self):
"""Define a list of fields that are used to automatically create forms
in the update and create views."""
if self.exclude_fields is None:
return forms.fields_for_model(self.model)
else:
exclude = self.exclude_fields
return forms.fields_for_model(self.model, exclude=exclude)
def __init__(self, *args, **kwargs):
super(RegistrationCommunityForm, self).__init__(*args, **kwargs)
fields_user = forms.fields_for_model(EcobasaUserProfile)
self.fields.update(fields_user)
self.fields['birth_date'].widget = DateL10nPicker()
self.fields['avatar'].required = False
fields_community = forms.fields_for_model(EcobasaCommunityProfile)
fields_community['contact_location_lat'].widget = forms.HiddenInput()
fields_community['contact_location_lon'].widget = forms.HiddenInput()
self.fields.update(fields_community)
def __init__(self, *args, **kwargs):
self.parent_pk = kwargs.pop('parent_pk', None)
super(PageNodeForm, self).__init__(*args, **kwargs)
PageGroup = get_model('fancypages', 'PageGroup')
self.fields['groups'].queryset = PageGroup.objects.all()
# we just need to store these for later to set the key order
page_field_names = self.fields.keys()
self.node_field_names = []
PageNode = get_node_model()
for field in PageNode._meta.fields:
if field.editable and \
field.name not in ['id', 'depth', 'numchild', 'path', 'slug']:
self.node_field_names.append(field.name)
additional_fields = forms.fields_for_model(
PageNode, fields=self.node_field_names)
self.fields.update(additional_fields)
# if we have a node instance, initialise the page-related fields
# with the appropriate values
instance = kwargs.get('instance')
if instance:
for field_name in self.node_field_names:
self.fields[field_name].initial = getattr(
instance.node, field_name)
# update the field order for the page and node fields
self.fields.keyOrder = self.node_field_names + page_field_names
def generate_fields(self):
self.fields["type"] = forms.ChoiceField(choices=[
("PersonContact", _("Person")),
("CompanyContact", _("Company"))
], label=_("Type"))
self.fields["groups"] = forms.ModelMultipleChoiceField(
queryset=ContactGroup.objects.all(),
initial=(self.instance.groups.all() if self.instance.pk else ()),
required=False,
widget=forms.CheckboxSelectMultiple(),
label=_("Contact Groups")
)
self.fields_by_model = {}
classes = (Contact, PersonContact, CompanyContact)
if self.contact_class:
classes = (self.contact_class, Contact,)
self._meta.model = classes[0]
for model_cls in classes:
model_name = str(model_cls.__name__)
model_fields = forms.fields_for_model(
model_cls, fields=self.FIELDS_BY_MODEL_NAME[model_name], formfield_callback=self.formfield_callback)
self.fields_by_model[model_name] = model_fields
self.fields.update(model_fields.items())
if self.contact_class:
self.fields.pop("type") # Can't change that.
if not self.instance.pk:
self.fields.pop("is_active")
def get_readonly_fields(self, request, obj=None):
"""Lock the document after seeking approval for all but superusers."""
if obj and request.user.is_superuser:
return ()
elif obj and request.user in obj.get_users_with_change_permissions():
return super(DocumentAdmin, self).get_readonly_fields(request, obj)
else:
return fields_for_model(obj, exclude=self.exclude).keys()
def from_model(cls, instance, form_kwargs=None):
# Create a Form from a model instance. The form has fields for all of the fields in the model that are
# overridable
# Get the fields and attach it to the new form instance
if form_kwargs is None:
form_kwargs = {}
fields = [xx.name for xx in instance.get_overridable_fields()]
fields = fields_for_model(instance._meta.model, fields=fields)
new_obj = cls(**form_kwargs)
new_obj.fields = fields
return new_obj
def get_model_fields(self):
"""
Get model fields. Defaults to :obj:`.fields`.
"""
if self.fields:
return self.fields
else:
fields = list(forms.fields_for_model(self.get_model_class(), fields=self.fields).keys())
if self.roleid_field and self.roleid_field in fields:
fields.remove(self.roleid_field)
return fields
def __init__(self):
super(SubLocalForm,self).__init__(*args,**kwargs)
if not hasattr(self.Meta,'exclude'):
self.Meta.exclude = None
if not hasattr(self.Meta,'fields'):
self.Meta.fields = None
self.fields = fields_for_model(
Form.Meta.model,
fields=self.Meta.fields,
exclude=self.Meta.exclude)
print "fields", self.fields
def __init__(self, *args, **kwargs):
super(RegistrationMemberForm, self).__init__(*args, **kwargs)
fields_user = forms.fields_for_model(EcobasaUserProfile)
self.fields.update(fields_user)
self.fields['birth_date'].widget = DateL10nPicker()
self.fields['avatar'].required = False
# has_bus is a boolean field, but is represented as a button in the
# form. Form validation has to be told explicitly that this field is
# not required.
self.fields['has_bus'] = forms.CharField(
widget=forms.HiddenInput(),
label=self.fields['has_bus'].label,
required=False)
def __init__(self, *args, **kwargs):
super(RegistrationMemberForm, self).__init__(*args, **kwargs)
fields_user = forms.fields_for_model(EcobasaUserProfile)
self.fields.update(fields_user)
self.fields['birth_date'].widget = DateL10nPicker()
self.fields['avatar'].required = False
# has_bus is a boolean field, but is represented as a button in the
# form. Form validation has to be told explicitly that this field is
# not required.
self.fields['has_bus'] = forms.CharField(
widget=forms.HiddenInput(),
label=self.fields['has_bus'].label,
required=False)
def __init__(self, user, *args, **kwargs):
try:
instance = Profile.objects.get(user=user)
except Profile.DoesNotExist:
# User has no profile, try a blank one
# 用户没有配置文件，尝试一个空白
instance = Profile(user=user)
kwargs['instance'] = instance
super().__init__(*args, **kwargs)
# Get profile field names to help with ordering later
# 获取配置文件字段名称以帮助以后进行排序
profile_field_names = list(self.fields.keys())
# Get user field names (we look for core user fields first)
# 获取用户字段名称（我们首先查找核心用户字段）
core_field_names = set([f.name for f in User._meta.fields])
user_field_names = ['email']
for field_name in ('first_name', 'last_name'):
if field_name in core_field_names:
user_field_names.append(field_name)
user_field_names.extend(User._meta.additional_fields)
# Store user fields so we know what to save later
# 存储用户字段，这样我们就知道以后要保存什么
self.user_field_names = user_field_names
# Add additional user form fields
# 添加其他用户窗体字段
additional_fields = forms.fields_for_model(User,
fields=user_field_names)
self.fields.update(additional_fields)
# Ensure email is required and initialised correctly
# 确保需要电子邮件并正确初始化
self.fields['email'].required = True
# Set initial values
# 设置初始值
for field_name in user_field_names:
self.fields[field_name].initial = getattr(user, field_name)
# Ensure order of fields is email, user fields then profile fields
# 确保字段顺序是电子邮件，用户字段然后是配置文件字段
self.fields.keyOrder = user_field_names + profile_field_names
def get_fields(self, request, obj=None):
if self._changeable_fields(request, obj):
return super(ReadonlyModeMixin, self).get_fields(request, obj)
if self.fields is not None:
return self.fields
fields = None
if hasattr(self.form, '_meta'):
fields = getattr(self.form._meta, 'fields', None)
exclude = self.exclude
if exclude is None and hasattr(self.form, '_meta'):
exclude = getattr(self.form._meta, 'exclude', None)
fields = fields_for_model(self.model, fields, exclude)
return fields
def __init__(self, *args, **kwargs):
field_dict = forms.fields_for_model(self.model)
self.fields_name = [x for x in field_dict]
if self.exclude:
for x in self.fields_name:
if not x in self.exclude:
setattr(self,x,forms.BooleanField(required=False,label=field_dict[x].label,help_text=f'Order by {field_dict[x].label}'))
setattr(self,f'{x}_decrease',forms.BooleanField(required=False,label=f'{field_dict[x].label} decrease',help_text=f'Order by {field_dict[x].label} decreasingly'))
elif self.fields_to_order:
for x in self.fields_to_order:
key = [y for y in field_dict if x.startswith(y)]
if key:
key = key[0]
label = field_dict[key].label
setattr(self,x,forms.BooleanField(required=False,label=label,help_text=f'Order by {label}'))
setattr(self,f'{x}_decrease',forms.BooleanField(required=False,label=f'{label} decrease',help_text=f'Order by {label} decreasingly'))
else:
raise TypeError(f'{x} is not an atribute of {self.model}')
else:
for x in self.fields_name:
setattr(self,x,forms.BooleanField(required=False,label=field_dict[x].label,help_text=f'Order by {field_dict[x].label}'))
setattr(self,f'{x}_decrease',forms.BooleanField(required=False,label=f'{field_dict[x].label} decrease',help_text=f'Order by {field_dict[x].label} decreasingly'))
super(forms.Form, self).__init__(*args, **kwargs)
if self.exclude:
for x in self.fields_name:
if not x in self.exclude:
self.fields[x] = forms.BooleanField(required=False,label=field_dict[x].label,help_text=f'Order by {field_dict[x].label}')
self.fields[f'{x}_decrease'] = forms.BooleanField(required=False,label=f'{field_dict[x].label} decrease',help_text=f'Order by {field_dict[x].label} decreasingly')
elif self.fields_to_order:
for x in self.fields_to_order:
key = [y for y in field_dict if x.startswith(y)][0]
label = field_dict[key].label
self.fields[x] = forms.BooleanField(required=False,label=label,help_text=f'Order by {label}')
self.fields[f'{x}_decrease'] = forms.BooleanField(required=False,label=f'{label} decrease',help_text=f'Order by {label} decreasingly')
else:
for x in self.fields_name:
self.fields[x] = forms.BooleanField(required=False,label=field_dict[x].label,help_text=f'Order by {field_dict[x].label}')
self.fields[f'{x}_decrease'] = forms.BooleanField(required=False,label=f'{field_dict[x].label} decrease',help_text=f'Order by {field_dict[x].label} decreasingly')
class CreateForm(forms.Form):
module = ModuleChoiceField(
Module.objects.order_by('title',
'-start_date').exclude(is_cancelled=True),
label='Module',
help_text='Showing all courses on this programme',
)
enrolment_fields = forms.fields_for_model(models.Enrolment)
status = enrolment_fields['status']
def __init__(self,
*,
qa: QualificationAim,
missing_student_fields: list,
limit_modules=True,
**kwargs):
super().__init__(**kwargs)
# dynamically filter module options based on the programme
module_queryset = self.fields['module'].queryset.filter(
programme=qa.programme)
# limit modules to recent
if limit_modules:
module_queryset = module_queryset.filter(
start_date__gt=datetime.today() - relativedelta(months=3))
self.fields['module'].help_text = mark_safe(
'Showing recent and future courses on this programme. <a href="?all=true">Show all</a>'
)
self.fields['module'].queryset = module_queryset
# dynamically add fields for missing student attributes
student_fields = forms.fields_for_model(
model=Student,
fields=missing_student_fields,
widgets={'birthdate': DatePickerInput()}, # type: ignore
)
self.fields.update(**student_fields)
def clean(self):
# Disallow enrolling on full 'weekly classes' (portfolio=32) programs. Other workflows are more forgiving.
# TODO: replace with portfolio flags
module = self.cleaned_data.get('module')
if module and module.portfolio_id == 32 and module.is_full():
self.add_error('module', 'Module is full')
def render(self, name, value, attrs=None):
# Ignore this HTML this returns as we're going to use our own.
super().render(name, value, attrs)
# Get the model fields with their widgets
# TODO: if an option follows a relation we'll need to get the fields/widgest from the related model!
fields = fields_for_model(self.model)
# TODO:
# Only useful if a) not already done on page and with jquery added. So better idea is to supply
# context items for including jquery, and the datetimepiccker bits and for including this scriplet.
# i.e. not here.
script = "" # '<script>$(function(){$(".DateTimeField").datetimepicker({"format": datetime_format,"step" : 15});});</script>'
for index, (option, _) in enumerate(self.choices):
option = self.choices[index][0]
parts = option.split('__')
if parts[0] in fields:
fieldname = parts[0]
operation = parts[1] if len(parts) > 1 else "exact"
if operation in operation_text:
operation = operation_text[operation]
if fieldname in fields:
classify_widget(fields[fieldname])
label = fields[fieldname].label
widget = fields[fieldname].widget
widget.attrs["id"] = "filter_field{}".format(index)
value = self.initial_values.pop(fieldname, 'None')
else:
label = fieldname
widget = None
value = None
if widget:
self.choices[index] = (option, "{} {} {}".format(
label, operation,
widget.render(option, value, attrs=attrs)))
return mark_safe("<div id={}>".format(name) +
" and ".join([choice[1] for choice in self.choices]) +
"</div>" + script)
def __init__(self, user, *args, **kwargs):
try:
instance = Profile.objects.get(user=user)
except Profile.DoesNotExist:
# User has no profile, try a blank one
instance = Profile(user=user)
kwargs['instance'] = instance
super(UserAndProfileForm, self).__init__(*args, **kwargs)
# Get profile field names to help with ordering later
profile_field_names = list(self.fields.keys())
print (profile_field_names)
# Get user field names (we look for core user fields first)
core_field_names = set([f.name for f in User._meta.fields])
print (" core_field_names :,", core_field_names)
user_field_names = ['email']
for field_name in ('first_name', 'last_name'):
if field_name in core_field_names:
user_field_names.append(field_name)
user_field_names.extend(User._meta.additional_fields)
# Store user fields so we know what to save later
self.user_field_names = user_field_names
# Add additional user form fields
additional_fields = forms.fields_for_model(
User, fields=user_field_names)
print (" ~~~~~~",additional_fields)
self.fields.update(additional_fields)
# Ensure email is required and initialised correctly
self.fields['email'].required = True
# Set initial values
for field_name in user_field_names:
#print (" field_name: ",field_name )
self.fields[field_name].initial = getattr(user, field_name)
# Ensure order of fields is email, user fields then profile fields
self.fields.keyOrder = user_field_names + profile_field_names
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._related_field_model = {}
for field, related_fields in self.inline_fields.items():
model = self._meta.model
try: # reverse relation
related_model = model._meta.fields_map[field].related_model
except KeyError: # forward relation
related_model = getattr(model, field).field.related_model
self._related_field_model.update({field: related_model})
related_model_fields = fields_for_model(related_model,
related_fields)
for field_name, field_object in related_model_fields.items():
if self.instance and self.instance.pk:
setattr(
field_object, 'initial',
getattr_chain(self.instance,
'%s.%s' % (field, field_name)))
self.fields['%s_%s' % (field, field_name)] = field_object
def clean(self):
self._clean_captcha()
cleaned_data = super(NewsItemForm, self).clean()
# Reverse-geocode if we need to - eg. user clicked map
# but didn't give an address.
if not cleaned_data.get('location_name'):
if cleaned_data.get('location'):
from ebpub.geocoder.reverse import reverse_geocode
from ebpub.geocoder.reverse import ReverseGeocodeError
try:
block, distance = reverse_geocode(cleaned_data['location'])
cleaned_data['location_name'] = block.pretty_name
except ReverseGeocodeError:
logger.info(
"Saving NewsItem with no location_name because reverse-geocoding %(location)s failed"
% cleaned_data)
# Geocode if we can, and need to.
# Should not be necessary, but this is groundwork for #284.
if not cleaned_data.get('location'):
if cleaned_data.get('location_name'):
from ebpub.geocoder.base import full_geocode
try:
geocoded = full_geocode(
cleaned_data['location_name'].strip(), guess=True)
cleaned_data['location'] = geocoded['result'].location.wkt
except (IndexError, KeyError, AttributeError):
logger.info(
"Saving NewsItem with no location because geocoding %(location_name)s failed"
% cleaned_data)
# Note, any NewsItem fields that aren't listed in self._meta.fields
# have to be manually saved here, because that's the list that's
# normally consulted when setting attributes on the instance.
# ... And yes, clean() is normally responsible for setting
# attributes on the bound instance.
for key in forms.fields_for_model(self._meta.model):
if key in cleaned_data.keys():
setattr(self.instance, key, cleaned_data[key])
return cleaned_data
def __init__(self, *args, **kwargs):
self.club = kwargs.pop("club")
self.request_user = kwargs.pop("request_user")
self.club_members = kwargs.pop("club_members", None)
if not self.club_members:
self.club_members = (self.club.members.filter(
end_date=None).order_by("-role").all())
self.request_user_membership = self.club.get_membership_for(
self.request_user)
super(ClubMemberForm, self).__init__(*args, **kwargs)
# Using a ModelForm binds too much the form with the model and we don't want that
# We want the view to process the model creation since they are multiple users
# We also want the form to handle bulk deletion
self.fields.update(
forms.fields_for_model(
Membership,
fields=("role", "start_date", "description"),
widgets={"start_date": SelectDate},
))
# Role is required only if users is specified
self.fields["role"].required = False
# Start date and description are never really required
self.fields["start_date"].required = False
self.fields["description"].required = False
self.fields["users_old"] = forms.ModelMultipleChoiceField(
User.objects.filter(id__in=[
ms.user.id for ms in self.club_members if ms.can_be_edited_by(
self.request_user, self.request_user_membership)
]).all(),
label=_("Mark as old"),
required=False,
widget=forms.CheckboxSelectMultiple,
)
if not self.request_user.is_root:
self.fields.pop("start_date")
def __init__(self, user, *args, **kwargs):
self.user = user
try:
instance = Profile.objects.get(user=user)
except ObjectDoesNotExist:
# User has no profile, try a blank one
instance = Profile(user=user)
kwargs['instance'] = instance
super(UserAndProfileForm, self).__init__(*args, **kwargs)
# Get a list of profile fields to help with ordering later
profile_field_names = self.fields.keys()
del profile_field_names[profile_field_names.index('email')]
self.fields['email'].initial = self.instance.user.email
# Add user fields (we look for core user fields first)
core_field_names = set([f.name for f in User._meta.fields])
user_field_names = ['email']
for field_name in ('first_name', 'last_name'):
if field_name in core_field_names:
user_field_names.append(field_name)
user_field_names.extend(User._meta.additional_fields)
# Store user fields so we know what to save later
self.user_field_names = user_field_names
# Add additional user fields
additional_fields = forms.fields_for_model(
User, fields=user_field_names)
self.fields.update(additional_fields)
# Set initial values
for field_name in user_field_names:
self.fields[field_name].initial = getattr(user, field_name)
# Ensure order of fields is email, user fields then profile fields
self.fields.keyOrder = user_field_names + profile_field_names
def __init__(self, user, *args, **kwargs):
self.user = user
try:
instance = Profile.objects.get(user=user)
except ObjectDoesNotExist:
# User has no profile, try a blank one
instance = Profile(user=user)
kwargs['instance'] = instance
super(UserAndProfileForm, self).__init__(*args, **kwargs)
# Get a list of profile fields to help with ordering later
profile_field_names = self.fields.keys()
del profile_field_names[profile_field_names.index('email')]
self.fields['email'].initial = self.instance.user.email
# Add user fields (we look for core user fields first)
core_field_names = set([f.name for f in User._meta.fields])
user_field_names = ['email']
for field_name in ('first_name', 'last_name'):
if field_name in core_field_names:
user_field_names.append(field_name)
user_field_names.extend(User._meta.additional_fields)
# Store user fields so we know what to save later
self.user_field_names = user_field_names
# Add additional user fields
additional_fields = forms.fields_for_model(
User, fields=user_field_names)
self.fields.update(additional_fields)
# Set initial values
for field_name in user_field_names:
self.fields[field_name].initial = getattr(user, field_name)
# Ensure order of fields is email, user fields then profile fields
self.fields.keyOrder = user_field_names + profile_field_names
def __init__(self, *args, **kwargs):
"""
This mixin requires the form to have a group attribute. Use
:class:`~cosinnus.forms.group.GroupKwargModelFormMixin` for example::
class SomeForm(GroupKwargModelFormMixin, TagObjectFormMixin,
forms.ModelForm):
class Meta:
model = SomeModel
fields = ('field1', 'field2', )
"""
import warnings
warnings.warn('cosinnus.forms.tagged.TagObjectFormMixin is deprecated',
DeprecationWarning)
super(TagObjectFormMixin, self).__init__(*args, **kwargs)
if not hasattr(self, 'group'):
raise AttributeError("The %s class does not have an attribute "
"'group' defined. Try adding the "
"GroupKwargModelFormMixin before the "
"TagObjectFormMixin" %
self.__class__.__name__)
media_tag_fields = forms.fields_for_model(TagObject,
exclude=('group', ))
self.media_tag_fields_used = []
for name, field in six.iteritems(media_tag_fields):
if name not in self.fields:
self.fields[name] = field
self.media_tag_fields_used.append(name)
if self.instance.media_tag:
data = forms.model_to_dict(self.instance.media_tag,
fields=self.media_tag_fields_used)
self.initial.update(data)
def get_readonly_fields(self, request, obj=None):
"""Custon logic to toggle editing of ProjectPlan fields.
Logic in sequential order:
* Superusers and special roles can always edit.
* If document is not approved yet, and users has change permission,
then the user can edit all fields except endorsements.
* Approved SPPs are read-only.
* All other cases, e.g. users without change permissions,
default to DocumentAdmin.get_readonly_fields.
"""
special_user = obj and request.user and (
request.user.is_superuser or
request.user in obj.project.special_roles)
if special_user:
# Superusers and special roles can always edit SPPs
# snitch("ProjectPlan admin: editable for special user.")
return ()
elif (obj and not obj.is_approved and request.user and
request.user in obj.get_users_with_change_permissions()):
# Normal users can edit doc if not approved except endorsements
# snitch("ProjectPlan admin: non approved = editable except "
# "endorsements for team member.")
return ('bm_endorsement', 'hc_endorsement', 'ae_endorsement')
# if is_approved: all readonly
elif (obj and obj.is_approved):
# snitch("ProjectPlan admin: approved = read-only for normal user.")
return fields_for_model(obj, exclude=self.exclude).keys()
else:
# snitch("ProjectPlan admin: defaulting to DocumentAdmin.")
return super(ProjectPlanAdmin, self).get_readonly_fields(
request, obj)
def __init__(self, user, *args, **kwargs):
try:
instance = Profile.objects.get(user=user)
except Profile.DoesNotExist:
# User has no profile, try a blank one
instance = Profile(user=user)
kwargs['instance'] = instance
super().__init__(*args, **kwargs)
# Get profile field names to help with ordering later
profile_field_names = list(self.fields.keys())
# Get user field names (we look for core user fields first)
core_field_names = set([f.name for f in User._meta.fields])
user_field_names = ['email']
for field_name in ('first_name', 'last_name'):
if field_name in core_field_names:
user_field_names.append(field_name)
user_field_names.extend(User._meta.additional_fields)
# Store user fields so we know what to save later
self.user_field_names = user_field_names
# Add additional user form fields
additional_fields = forms.fields_for_model(
User, fields=user_field_names)
self.fields.update(additional_fields)
# Ensure email is required and initialised correctly
self.fields['email'].required = True
# Set initial values
for field_name in user_field_names:
self.fields[field_name].initial = getattr(user, field_name)
# Ensure order of fields is email, user fields then profile fields
self.fields.keyOrder = user_field_names + profile_field_names
def generate_fields(self):
self.fields["type"] = forms.ChoiceField(choices=[
("PersonContact", _("Person")), ("CompanyContact", _("Company"))
],
label=_("Type"))
self.fields["groups"] = forms.ModelMultipleChoiceField(
queryset=ContactGroup.objects.all(),
initial=(self.instance.groups.all() if self.instance.pk else ()),
required=False,
widget=forms.CheckboxSelectMultiple(),
label=_("Contact Groups"))
self.fields_by_model = {}
classes = (Contact, PersonContact, CompanyContact)
if self.contact_class:
classes = (
self.contact_class,
Contact,
)
self._meta.model = classes[0]
for model_cls in classes:
model_name = str(model_cls.__name__)
model_fields = forms.fields_for_model(
model_cls,
fields=self.FIELDS_BY_MODEL_NAME[model_name],
formfield_callback=self.formfield_callback)
self.fields_by_model[model_name] = model_fields
self.fields.update(model_fields.items())
if self.contact_class:
self.fields.pop("type") # Can't change that.
if not self.instance.pk:
self.fields.pop("is_active")
self.fields["account_manager"].widget = PersonContactChoiceWidget(
clearable=True)
def get_readonly_fields(self, request, obj=None):
"""Custom logic to toggle editing of ProjectPlan fields.
Logic in sequential order:
* Superusers and special roles can always edit.
* If document is not approved yet, and users has change permission,
then the user can edit all fields except endorsements.
* Approved SPPs are read-only.
* All other cases, e.g. users without change permissions,
default to DocumentAdmin.get_readonly_fields.
"""
special_user = obj and request.user and (request.user.is_superuser
or request.user
in obj.project.special_roles)
if special_user:
# Superusers and special roles can always edit SPPs
logger.debug("ProjectPlan admin: editable for special user.")
return ()
elif (obj and not obj.is_approved and request.user
and request.user in obj.get_users_with_change_permissions()):
# Normal users can edit doc if not approved except endorsements
logger.debug("ProjectPlan admin: non approved = editable except "
"endorsements for team member.")
return ('bm_endorsement', 'hc_endorsement', 'ae_endorsement')
# if is_approved: all readonly
elif (obj and obj.is_approved):
logger.debug("ProjectPlan admin: approved = read-only "
"for normal user.")
return fields_for_model(obj, exclude=self.exclude).keys()
else:
logger.debug("ProjectPlan admin: defaulting to DocumentAdmin.")
return super(ProjectPlanAdmin,
self).get_readonly_fields(request, obj)
def clean(self):
self._clean_captcha()
cleaned_data = super(NewsItemForm, self).clean()
# Reverse-geocode if we need to - eg. user clicked map
# but didn't give an address.
if not cleaned_data.get('location_name'):
if cleaned_data.get('location'):
from ebpub.geocoder.reverse import reverse_geocode
from ebpub.geocoder.reverse import ReverseGeocodeError
try:
block, distance = reverse_geocode(cleaned_data['location'])
cleaned_data['location_name'] = block.pretty_name
except ReverseGeocodeError:
logger.info("Saving NewsItem with no location_name because reverse-geocoding %(location)s failed" % cleaned_data)
# Geocode if we can, and need to.
# Should not be necessary, but this is groundwork for #284.
if not cleaned_data.get('location'):
if cleaned_data.get('location_name'):
from ebpub.geocoder.base import full_geocode
try:
geocoded = full_geocode(cleaned_data['location_name'].strip(),
guess=True)
cleaned_data['location'] = geocoded['result'].location.wkt
except (IndexError, KeyError, AttributeError):
logger.info("Saving NewsItem with no location because geocoding %(location_name)s failed" % cleaned_data)
# Note, any NewsItem fields that aren't listed in self._meta.fields
# have to be manually saved here, because that's the list that's
# normally consulted when setting attributes on the instance.
# ... And yes, clean() is normally responsible for setting
# attributes on the bound instance.
for key in forms.fields_for_model(self._meta.model):
if key in cleaned_data.keys():
setattr(self.instance, key, cleaned_data[key])
return cleaned_data
def __init__(self, *args, **kwargs):
super(FilterForm, self).__init__(*args, **kwargs)
for column in filtered_columns_with_ui:
name = column.name
filter_field = column.get('filter_field')
if 'filter_choices' in column and not filter_field:
filter_choices = column.filter_choices
if isinstance(filter_choices, QuerySet):
filter_choices = [(x.pk, x) for x in filter_choices]
if ('', '') not in filter_choices:
filter_choices = [('', '')] + filter_choices
filter_field = forms.ChoiceField(choices=filter_choices)
if filter_field:
self.fields[name] = filter_field
else:
model = table.data.model
last_name = name.split('__')[-1]
for x in name.split('__')[:-1]:
try:
model = getattr(model, x).get_queryset().model
except AttributeError: # pragma: no cover
# Support for old Django versions
model = getattr(model, x).get_query_set().model
field_by_name = forms.fields_for_model(model)
self.fields[name] = field_by_name[last_name]
for field_name, field in self.fields.items():
if isinstance(field, fields.BooleanField):
self.fields[field_name] = forms.ChoiceField(label=field.label, help_text=field.help_text, required=False, choices=[('', ''), ('1', 'Yes'), ('0', 'No')])
self.fields[field_name].creation_counter = field.creation_counter
for field in self.fields.values():
field.required = False
field.blank = True
field.null = True
if hasattr(field, 'choices') and type(field.choices) in (list, tuple) and field.choices[0] != ('', ''):
field.choices = [('', '')] + field.choices
def show_object_ex(record,
deep_inspection=False,
empty_value=None,
simplify_object=True):
if not record:
return None
if isinstance(record, models.Model):
meta_data = fields_for_model(record)
data = {}
for key in meta_data:
obj = meta_data[key]
name = obj.label
field = getattr(record, key)
if hasattr(field, 'target_field'):
if deep_inspection:
val = [
show_object_ex(rec, deep_inspection, empty_value)
for rec in field.all()
]
else:
if simplify_object:
val = [str(rec) for rec in field.all()]
else:
val = [rec for rec in field.all()]
else:
if hasattr(field, 'get'):
val = field.get()
else:
val = field
if val is None:
val = empty_value
data[name] = val
else:
data = record
return {'record': data}
def clean(self):
self._clean_captcha()
cleaned_data = super(NewsItemForm, self).clean()
# Reverse-geocode if we need to.
if not cleaned_data['location_name']:
if cleaned_data['location']:
from ebpub.geocoder.reverse import reverse_geocode
try:
block, distance = reverse_geocode(cleaned_data['location'])
cleaned_data['location_name'] = block.pretty_name
except ReverseGeocodeErrror:
logger.info("Saving NewsItem with no location_name because reverse-geocoding %(location)s failed" % cleaned_data)
# Note, any NewsItem fields that aren't listed in self._meta.fields
# have to be manually saved here, because that's the list that's
# normally consulted when setting attributes on the instance.
# ... And yes, clean() is normally responsible for setting
# attributes on the bound instance.
for key in forms.fields_for_model(self._meta.model):
if key in cleaned_data.keys():
setattr(self.instance, key, cleaned_data[key])
return cleaned_data
class UserForm(forms.ModelForm, BootstrapMixin):
# steal form field definitions for the User model
locals().update(
forms.fields_for_model(User,
fields=('first_name', 'last_name', 'email')))
class Meta:
model = UserProfile
fields = ('title', 'first_name', 'last_name', 'email', 'picture',
'delegates')
def __init__(self, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
# fix generated form
self.fields['delegates'].required = False
self.fields['delegates'].queryset = User.objects.extra(
select={
'lower_username': '******'
}).order_by('lower_username')
self.fields['delegates'].help_text = ""
# load user fields
self.fields['first_name'].initial = self.instance.user.first_name
self.fields['last_name'].initial = self.instance.user.last_name
self.fields['email'].initial = self.instance.user.email
def save(self, *args, **kw):
# first save the user, so that the profile gets created for sure
self.instance.user.first_name = self.cleaned_data.get('first_name')
self.instance.user.last_name = self.cleaned_data.get('last_name')
self.instance.user.email = self.cleaned_data.get('email')
self.instance.user.save()
self.instance = UserProfile.get_for_user(self.instance.user)
super(UserForm, self).save(*args, **kw)
from django.views.generic.list import ListView
from django.views.generic.edit import UpdateView
from django import forms
from django.forms import fields_for_model, modelformset_factory
from goingout.models import Venue, Ratings
ratings_fields = fields_for_model(Ratings).keys()
class VenueDetailForm(forms.ModelForm):
ratings = None
class Meta:
model = Venue
fields = '__all__'
# Assign all ratings widgets as disabled radio select buttons
widgets = {r: forms.RadioSelect(attrs={'disabled': 'disabled'}) for r in ratings_fields}
class VenueDetail(UpdateView):
""" This is a effectively a detail class but will use read-only ratings form fields to display """
model = Venue
form_class = VenueDetailForm
template_name = 'goingout/venue_detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Create a list of fields for the ratings section, to iterate in the template
context['ratings'] = [context['form'][r] for r in ratings_fields]
context['venue_list'] = Venue.objects.all() # Provide other venues for display on the map
class ConditionAdmin(admin.ModelAdmin):
list_display = [
"_instrument", "_data_getter", "condition_group", "_test_results"
]
list_filter = ["date_created", "date_modified"]
search_fields = [
"instrument__text",
"data_getter",
"condition_group__nickname",
"condition_group__cases__nickname",
]
date_hierarchy = "date_created"
readonly_fields = ["_resolver_info", "_test_results"]
fields = list(fields_for_model(
models.Condition).keys()) + ["_resolver_info", "_test_results"]
def get_queryset(self, request):
queryset = super(ConditionAdmin, self).get_queryset(request)
self.request = request
return queryset
def formfield_for_dbfield(self, db_field, **kwargs):
if db_field.name == "data_getter":
kwargs["widget"] = Textarea
return super(ConditionAdmin,
self).formfield_for_dbfield(db_field, **kwargs)
def _instrument(self, instance):
statuses = self._do_tests(instance)
def boolean_status(status):
if isinstance(status, Exception):
return None
return status
app_results = "".join([
_boolean_icon(boolean_status(status)) for label, status in statuses
if not label.startswith("django_input_collection.")
])
builtin_results = "".join([
_boolean_icon(boolean_status(status)) for label, status in statuses
if label.startswith("django_input_collection.")
])
return format_html(
'<div style="width: 200px;"><a href="{}">{}</a><hr><div>{}{}</div></div>',
*[
instance.pk,
instance.instrument,
mark_safe(app_results + (" • " if app_results else "")),
mark_safe(builtin_results),
],
)
_instrument.short_description = """Instrument"""
def _data_getter(self, instance):
data_getter = mark_safe("<div>{}</div>".format(instance.data_getter))
return data_getter + self._resolver_info(instance)
_data_getter.short_description = """Data Getter"""
def _resolver_info(self, instance):
if instance.pk is None:
return "(Unsaved)"
resolver, data, error = instance.resolve(raise_exception=False)
if resolver:
return format_html(
"<dt>{}</dt><dd>{}{}</dd>",
".".join((resolver.__module__, resolver.__class__.__name__)),
format_html("<code>{}</code>", repr(data))
if not error else "",
format_html(
'<code style="color: orange;">Lookup failed! (Will use collector class default.)<br>{}</code>',
error,
) if error else "",
)
return format_html(
'<div style="color: red;">{}</div>',
"NO MATCHING RESOLVER",
)
_resolver_info.short_description = """Resolver"""
def _test_results(self, instance):
statuses = self._do_tests(instance)
for i, (label, status) in enumerate(statuses):
if isinstance(status, Exception):
# log.error('Exception during %s: %s', label, status)
status = format_html('<code style="color: red;">{}</code>',
status)
else:
status = _boolean_icon(status)
statuses[i][1] = status
return mark_safe(
"<dl>%s</dl>" %
(format_html_join("", "<dt>{}</dt><dd>{}</dd>", statuses), ))
_test_results.short_description = """Results"""
# Internals
def _do_tests(self, instance):
if instance.pk is None:
return []
from .collection.collectors import registry
collection_request = instance.instrument.collection_request
statuses = []
context = {"user": self.request.user}
for collector_class in sorted(registry.values(),
key=lambda c:
(c.__module__, c.__name__)):
try:
collector = collector_class(
collection_request=collection_request, context=context)
status = collector.is_condition_successful(
instance, raise_exception=False)
except Exception as e:
log.exception(e)
status = e
statuses.append([
".".join(
(collector_class.__module__, collector_class.__name__)),
status,
])
return statuses
self.instance.coordinates = None
self.instance.coordinates_type = None
return super().save(commit=True)
def schedule_tasks(self):
if self.must_geolocate():
self.geocoding_task.delay(self.instance.pk)
LocationFormMixin.declared_fields = fields_for_model(
LocationMixin,
fields=[
"location_name",
"location_address1",
"location_address2",
"location_city",
"location_zip",
"location_country",
],
)
class ContactFormMixin:
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["contact_email"].required = True
self.fields["contact_phone"].required = True
def __init__(self, instance=None, *args, **kwargs):
_fields = 'attachment'
_initial = model_to_dict(instance.problem, _fields) if instance is not None else {}
super(ProblemSubmissionForm, self).__init__(initial=_initial, instance=instance, *args, **kwargs)
self.fields.update(fields_for_model(ProblemImage, _fields))
# -*- coding=UTF-8 -*-
"""
author:hamioo
date:2018/1/12
describle:
"""
from models import Publisher
from django import forms
TOPIC_CHOICES = (
('general', 'General enquiry'),
('bug', 'Bug report'),
('suggestion', 'Suggestion'),
)
class ContactForm(forms.Form):
topic = forms.ChoiceField(choices=TOPIC_CHOICES)
message = forms.CharField(widget=forms.Textarea(),initial="Replacce with your feedback")
sender = forms.EmailField(required=False)
def clean_message(self):
message = self.cleaned_data.get('message','')
num_words = len(message.split())
if num_words < 4:
raise forms.ValidationError("Not enough words")
return message
PublisherForm = forms.fields_for_model(Publisher)
