py_tasks_melange: comparison app/soc/views/helper/surveys.py

equal deleted inserted replaced

-:d612b48e6e12
+:2e096acc8720
 from soc.logic.lists import Lists
 from soc.models.survey import COMMENT_PREFIX
 from soc.models.survey import SurveyContent
+# TODO(ajaksu) add this to template
+REQUIRED_COMMENT_TPL = """
+<label for="required_for_{{ name }}">Required</label>
+<select id="required_for_{{ name }}" name="required_for_{{ name }}">
+<option value="True" {% if is_required %} selected='selected' {% endif %}
+>True</option>
+<option value="False" {% if not is_required %} selected='selected'
+{% endif %}>False</option>
+</select><br/>
+<label for="comment_for_{{ name }}">Allow Comments</label>
+<select id="comment_for_{{ name }}" name="comment_for_{{ name }}">
+<option value="True" {% if has_comment %} selected='selected' {% endif %}
+>True</option>
+<option value="False" {% if not has_comment %} selected='selected'
+{% endif %}>False</option>
+</select><br/>
+"""
 class SurveyForm(djangoforms.ModelForm):
 """Main SurveyContent form.
 This class is used to produce survey forms for several circumstances:
 - Admin creating survey from scratch
 if not from_content:
 self.data[field] = value
 # find correct field type
 addField = self.fields_map[schema.getType(field)]
-addField(field, value, extra_attrs, schema, label=label, comment=comment)
+# check if question is required, it's never required when editing
-# handle comments
+required = not self.editing and schema.getRequired(field)
-comment_name = COMMENT_PREFIX + field
+kwargs = dict(label=label, req=required)
-if comment_name in post_dict or hasattr(self.survey_record, comment_name):
-self.data[comment_name] = comment
+# add new field
+addField(field, value, extra_attrs, schema, **kwargs)
+# handle comments if question allows them
+if schema.getHasComment(field):
+self.data[COMMENT_PREFIX + field] = comment
 self.addCommentField(field, comment, extra_attrs, tip='Add a comment.')
 return self.insertFields()
 def insertFields(self):
 if property in self.survey_fields:
 self.fields.insert(position - 1, property,
 self.survey_fields[property])
 return self.fields
-def addLongField(self, field, value, attrs, schema, req=False, label='',
+def addLongField(self, field, value, attrs, schema, req=True, label='',
 tip='', comment=''):
 """Add a long answer fields to this form.
 params:
 field: the current field
 label: label for field
 tip: tooltip text for field
 comment: initial comment value for field
 """
-widget = widgets.Textarea(attrs=attrs)
+# use a widget that allows setting required and comments
+has_comment = schema.getHasComment(field)
+is_required = schema.getRequired(field)
+widget = LongTextarea(is_required, has_comment, attrs=attrs,
+editing=self.editing)
 if not tip:
 tip = 'Please provide a long answer to this question.'
 question = CharField(help_text=tip, required=req, label=label,
 tip: tooltip text for field
 comment: initial comment value for field
 """
 attrs['class'] = "text_question"
-widget = widgets.TextInput(attrs=attrs)
+# use a widget that allows setting required and comments
+has_comment = schema.getHasComment(field)
+is_required = schema.getRequired(field)
+widget = ShortTextInput(is_required, has_comment, attrs=attrs,
+editing=self.editing)
 if not tip:
 tip = 'Please provide a short answer to this question.'
 question = CharField(help_text=tip, required=req, label=label,
 # TODO(ajaksu) need to allow checking checkboxes by default
 if self.survey_record and isinstance(value, basestring):
 # pass value as 'initial' so MultipleChoiceField renders checked boxes
 value = value.split(',')
-else:
-value = None
 these_choices = [(v,v) for v in getattr(self.survey_content, field)]
 if not tip:
 tip = 'Please select one or more of these choices.'
 self.schema = eval(schema)
 def getType(self, field):
 return self.schema[field]["type"]
+def getRequired(self, field):
+"""Check whether survey question is required.
+"""
+return self.schema[field]["required"]
+def getHasComment(self, field):
+"""Check whether survey question allows adding a comment.
+"""
+return self.schema[field]["has_comment"]
 def getRender(self, field):
 return self.schema[field]["render"]
 def getWidget(self, field, editing, attrs):
 """Get survey editing or taking widget for choice questions.
 """
 if editing:
 kind = self.getType(field)
 render = self.getRender(field)
-widget = UniversalChoiceEditor(kind, render)
+is_required = self.getRequired(field)
+has_comment = self.getHasComment(field)
+widget = UniversalChoiceEditor(kind, render, is_required, has_comment)
 else:
 widget = WIDGETS[self.schema[field]['render']](attrs=attrs)
 return widget
 def getLabel(self, field):
 """Edit interface for choice questions.
 Allows adding and removing options, re-ordering and editing option text.
 """
-def __init__(self, kind, render, attrs=None, choices=()):
+def __init__(self, kind, render, is_required, has_comment, attrs=None,
+choices=()):
+"""
+params:
+kind: question kind (one of selection, pick_multi or pick_quant)
+render: question widget (single_select, multi_checkbox or quant_radio)
+is_required: bool, controls selection in the required_for field
+has_comments: bool, controls selection in the has_comments field
+"""
 self.attrs = attrs or {}
 # Choices can be any iterable, but we may need to render this widget
 # multiple times. Thus, collapse it into a list so it can be consumed
 # more than once.
 self.choices = list(choices)
 self.kind = kind
 self.render_as = render
+self.is_required = is_required
+self.has_comment = has_comment
 def render(self, name, value, attrs=None, choices=()):
-""" renders UCE widget
+"""Render UCE widget.
+Option reordering, editing, addition and deletion are added here.
 """
 if value is None:
 value = ''
 is_select=selected * (self.render_as == 'single_select'),
 is_checkboxes=selected * (self.render_as == 'multi_checkbox'),
 is_radio_buttons=selected * (self.render_as == 'quant_radio'),
 )
+# set required and has_comment selects
+context.update(dict(
+is_required = self.is_required,
+has_comment = self.has_comment,
+))
 str_value = forms.util.smart_unicode(value) # normalize to string.
 chained_choices = enumerate(chain(self.choices, choices))
 choices = {}
 for i, (option_value, option_label) in chained_choices:
 """
 #TODO(james): Ensure that more than one quant cannot be selected
 def __init__(self, *args, **kwargs):
 super(PickQuantField, self).__init__(*args, **kwargs)
+class LongTextarea(widgets.Textarea):
+"""Set whether long question is required or allows comments.
+"""
+def __init__(self, is_required, has_comment, attrs=None, editing=False):
+"""Initialize widget and store editing mode.
+params:
+is_required: bool, controls selection in the 'required' extra field
+has_comments: bool, controls selection in the 'has_comment' extra field
+editing: bool, controls rendering as plain textarea or with extra fields
+"""
+self.editing = editing
+self.is_required = is_required
+self.has_comment = has_comment
+super(LongTextarea, self).__init__(attrs)
+def render(self, name, value, attrs=None):
+"""Render plain textarea or widget with extra fields.
+Extra fields are 'required' and 'has_comment'.
+"""
+# plain text area
+output = super(LongTextarea, self).render(name, value, attrs)
+if self.editing:
+# add 'required' and 'has_comment' fields
+context = dict(name=name, is_required=self.is_required,
+has_comment=self.has_comment)
+template = loader.get_template_from_string(REQUIRED_COMMENT_TPL)
+rendered = template.render(context=loader.Context(dict_=context))
+output =  rendered + output
+output = '<fieldset>' + output + '</fieldset>'
+return output
+class ShortTextInput(widgets.TextInput):
+"""Set whether short answer question is required or allows comments.
+"""
+def __init__(self, is_required, has_comment, attrs=None, editing=False):
+"""Initialize widget and store editing mode.
+params:
+is_required: bool, controls selection in the 'required' extra field
+has_comments: bool, controls selection in the 'has_comment' extra field
+editing: bool, controls rendering as plain text input or with extra fields
+"""
+self.editing = editing
+self.is_required = is_required
+self.has_comment = has_comment
+super(ShortTextInput, self).__init__(attrs)
+def render(self, name, value, attrs=None):
+"""Render plain text input or widget with extra fields.
+Extra fields are 'required' and 'has_comment'.
+"""
+# plain text area
+output = super(ShortTextInput, self).render(name, value, attrs)
+if self.editing:
+# add 'required' and 'has_comment' fields
+context = dict(name=name, is_required=self.is_required,
+has_comment=self.has_comment)
+template = loader.get_template_from_string(REQUIRED_COMMENT_TPL)
+rendered = template.render(context=loader.Context(dict_=context))
+output =  rendered + output
+output = '<fieldset>' + output + '</fieldset>'
+return output
 class PickOneSelect(forms.Select):
 """Stub for customizing the single choice select widget.
 """
 value = post_dict.getlist(name)
 response_dict[name] = value
 # handle comments
-comment_name = COMMENT_PREFIX + name
+if schema.getHasComment(name):
-if comment_name in post_dict:
+comment_name = COMMENT_PREFIX + name
 comment = post_dict.get(comment_name)
 if comment:
 response_dict[comment_name] = comment
 return response_dict

changeset 2502	2e096acc8720
parent 2501	d612b48e6e12
child 2506	c98bf890156e