class CodebookNewCodeForm(forms.Form):
codebook = forms.ModelChoiceField(queryset=Codebook.objects.all())
label = forms.CharField()
language = forms.ModelChoiceField(queryset=Language.objects.all())
parent = forms.ModelChoiceField(queryset=Code.objects.all(),
required=False)
def __init__(self, options=None, codebook=None):
super(CodebookNewCodeForm, self).__init__(options)
if codebook:
self.fields["codebook"].initial = codebook
self.fields["codebook"].widget = HiddenInput()
self.fields['parent'].queryset = (
self.fields['parent'].queryset.filter(
id__in=codebook.get_code_ids()))
def save(self):
code = Code.create(label=self.cleaned_data['label'],
language=self.cleaned_data['language'])
self.cleaned_data['codebook'].add_code(code,
self.cleaned_data.get('parent'))
class Meta:
model = CodebookCode
fields = ('codebook', 'code', 'parent')
class CodingJobForm(forms.ModelForm):
unitschema = forms.ModelChoiceField(CodingSchema.objects.none(),
widget=widgets.JQuerySelect)
articleschema = forms.ModelChoiceField(CodingSchema.objects.none(),
widget=widgets.JQuerySelect)
coder = forms.ModelChoiceField(User.objects.none(),
widget=widgets.JQuerySelect)
articleset = forms.ModelChoiceField(ArticleSet.objects.none(),
widget=widgets.JQuerySelect)
def __init__(self, edit=True, project=None, **kwargs):
"""
@type edit: boolean
@param edit: Is this form used to edit a CodingJob?
"""
super(CodingJobForm, self).__init__(**kwargs)
project = project or self.instance.project
# These field are mandatory for ArticleSet, but implicit for every
# form initialized
del self.fields['insertuser']
del self.fields['project']
if edit is True:
# Codingjobs can't change articlesets while being coded
del self.fields['articleset']
else:
# Only display articlesets in project
qs = ArticleSet.objects.filter(
Q(project=project) | Q(projects_set=project))
self.fields['articleset'].queryset = qs
schemas_qs = project.get_codingschemas()
# Select choices available in project
self.fields['coder'].queryset = User.objects.filter(
projectrole__project=project)
self.fields['coder'].choices = gen_user_choices(project)
self.fields['unitschema'].queryset = schemas_qs.filter(
isarticleschema=False)
self.fields['articleschema'].queryset = schemas_qs.filter(
isarticleschema=True)
class Meta:
model = CodingJob
exclude = ()
class UserForm(forms.ModelForm):
affiliation = forms.ModelChoiceField(queryset=Affiliation.objects.all())
role = forms.ModelChoiceField(queryset=Role.objects.all())
language = forms.ModelChoiceField(queryset=Language.objects.all())
theme = forms.ChoiceField(choices=[(t, t) for t in THEMES])
def __init__(self, request, editing=True, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
if not request.user.is_anonymous():
uprofile = request.user.userprofile
# Only show roles lesser or equal to the current role of the user
self.fields['role'].queryset = Role.objects.filter(
projectlevel=False, id__lte=uprofile.role.id)
# Set initial values for this user
self.fields[
'role'].initial = uprofile.role if not editing else kwargs[
'instance'].userprofile.role
self.fields['affiliation'].initial = uprofile.affiliation
self.fields['language'].initial = uprofile.language
self.fields['theme'].initial = uprofile.theme
# We don't use Django groups and permissions
for fi in ("groups", "user_permissions"):
if fi in self.fields:
del self.fields[fi]
if editing:
del self.fields["username"]
def save(self, commit=True):
u = super(UserForm, self).save(commit)
up = u.userprofile
up.affiliation = self.cleaned_data['affiliation']
up.role = self.cleaned_data['role']
up.language = self.cleaned_data['language']
up.theme = self.cleaned_data['theme']
up.save()
return u
class Meta:
model = User
fields = ("affiliation", "role", "language", "theme")
class ProjectForm(forms.ModelForm):
guest_role = forms.ModelChoiceField(queryset=Role.objects.filter(projectlevel=True),
required=False, help_text="Leaving this value \
empty means it will not be readable at all.",
initial=11)
def __init__(self, *args, **kwargs):
super(ProjectForm, self).__init__(*args, **kwargs)
for fld in ('codingschemas', 'codebooks', 'owner'):
del self.fields[fld]
class Meta:
model = models.project.Project
def clean_owner(self):
self.cleaned_data = User.objects.get(id=self.cleaned_data['owner'])
return self.cleaned_data
class UploadScriptForm(forms.Form):
file = forms.FileField(help_text="Supported archives: zip")
encoding = forms.ChoiceField(choices=((1, "ISO-8859-15"), (2, "UTF-8"), (3, "LATIN-1")),
initial=1, help_text="Try to change this value when character"+
" issues arise.")
exi_set = forms.ModelChoiceField(queryset=ArticleSet.objects.all(),
label="Existing set", required=False)
new_set = forms.CharField(max_length=100, required=False)
script = forms.ChoiceField(choices=[(sc, sc) for sc in article_upload.__all__])
def __init__(self, project, *args, **kwargs):
super(UploadScriptForm, self).__init__(*args, **kwargs)
exi = self.fields['exi_set']
exi.queryset = exi.queryset.filter(project=project)
self.project = project
def _get_zip_files(self, fo):
zip = zipfile.ZipFile(fo)
for fi in zip.infolist():
if fi.filename.split('.')[-1].lower in ALLOWED_EXTENSIONS:
yield fi.filename, zip.read(fi)
else:
logger.debug("%s not in ALLOWED_EXTENSIONS, skipping.." % fi.filename)
def clean_new_set(self):
if not (self.cleaned_data['new_set'] or self.cleaned_data['exi_set']):
raise forms.ValidationError("Either choose an existing set from the list above or\
fill in this field to create a new set.")
new_set = ArticleSet.objects.filter(project=self.project,
name=self.cleaned_data['new_set'])
if len(new_set) != 0:
raise forms.ValidationError("Set already exists!")
return self.cleaned_data['new_set']
def clean_file(self):
data = self.cleaned_data['file']
ext = unicode(data).split('.')[-1]
if ext.lower() not in ALLOWED_EXTENSIONS + ['zip']:
raise forms.ValidationError("%s is not a supported format" % ext)
# Extract all txt-files from archive
if ext.lower() == 'zip':
try:
return list(self._get_zip_files(data))
except zipfile.BadZipfile:
raise forms.ValidationError("%s is not a zipfile" % data)
# Read txt file
elif ext.lower() in ALLOWED_EXTENSIONS:
return [(unicode(data), data.read())]
def clean_encoding(self):
ident = self.cleaned_data['encoding']
enc = dict(self.fields['encoding'].choices).get(int(ident))
if 'file' not in self.cleaned_data:
# Fail silently, as 'file' will fail anyway
return enc
# Test encoding
for fn, bytes in self.cleaned_data['file']:
try:
bytes.decode(enc)
except UnicodeDecodeError:
raise ValidationError("Couldn't decode '%s' with '%s'" % (fn, enc))
return enc
