class Meta:
fields = "__all__"
model = models.Asset
widgets = {
'credit_account': Select2Widget(attrs={'data-width': '20rem'})
}
def test_empty_css_setting(self, settings):
settings.SELECT2_CSS = ''
sut = Select2Widget()
result = sut.media.render()
assert '.css' not in result
def test_custom_tag_attrs_Select2Widget(self):
widget = Select2Widget(attrs={'data-minimum-input-length': '3'})
output = widget.render('name', 'value')
assert 'data-minimum-input-length="3"' in output
def test_default_media(self):
sut = Select2Widget()
result = sut.media.render()
assert '//cdnjs.cloudflare.com/ajax/libs/select2/4.0.3/js/select2.min.js' in result
assert '//cdnjs.cloudflare.com/ajax/libs/select2/4.0.3/css/select2.min.css' in result
assert 'django_select2/django_select2.js' in result
def test_empty_js_setting(self, settings):
settings.SELECT2_JS = ''
sut = Select2Widget()
result = sut.media.render()
assert 'django_select2/django_select2.js' in result
def test_multiple_css_setting(self, settings):
settings.SELECT2_CSS = ["select2.css", "select2-theme.css"]
sut = Select2Widget()
result = sut.media.render()
assert "select2.css" in result
assert "select2-theme.css" in result
class Meta:
model = Entrada
fields = ('empleado', 'paciente', 'descripcion', 'area')
labels = {'area': "Área"}
widgets = {'area': Select2Widget()}
class AxisOptionsInlineForm(OptionsInlineFormBase):
label = forms.CharField(
required=True,
widget=Select2Widget(choices=get_chartjs_axis_options()))
class WorkshopForm(ModelForm):
class CategoryChoiceField(ModelMultipleChoiceField):
def label_from_instance(self, obj):
return obj.name
class TypeChoiceField(ModelChoiceField):
def label_from_instance(self, obj):
return obj.name
# Note that the querysets for category and type are overwritten in __init__, but the argument is required here
category = CategoryChoiceField(
label="Kategorie",
queryset=WorkshopCategory.objects.all(),
widget=Select2MultipleWidget(attrs={'width': '200px'}))
type = TypeChoiceField(label="Rodzaj zajęć",
queryset=WorkshopType.objects.all(),
widget=Select2Widget(attrs={'width': '200px'}))
qualification_problems = FileField(
required=False,
widget=FileInput(),
label='Zadania kwalifikacyjne (wymagany format PDF):',
validators=[FileExtensionValidator(allowed_extensions=['pdf'])])
class Meta:
model = Workshop
fields = [
'title', 'name', 'type', 'category', 'proposition_description',
'qualification_problems', 'is_qualifying',
'solution_uploads_enabled', 'max_points',
'qualification_threshold', 'short_description', 'page_content',
'page_content_is_public'
]
labels = {
'title':
'Tytuł',
'name':
'Nazwa (w URLach)',
'proposition_description':
'Opis propozycji warsztatów',
'is_qualifying':
'Czy warsztaty są kwalifikujące',
'solution_uploads_enabled':
'Czy przesyłanie rozwiązań przez stronę jest włączone',
'max_points':
'Maksymalna liczba punktów możliwa do uzyskania',
'qualification_threshold':
'Minimalna liczba punktów potrzebna do kwalifikacji',
'short_description':
'Krótki opis warsztatów',
'page_content':
'Strona warsztatów',
'page_content_is_public':
'Zaznacz, jeśli opis jest gotowy i może już być publiczny.'
}
help_texts = {
'short_description':
'Zachęć uczestnika do zainteresowania się Twoimi warsztatami w max 140 znakach. Wyświetlany na stronie z programem.',
'is_qualifying':
'(odznacz, jeśli nie zamierzasz dodawać zadań i robić kwalifikacji)',
'solution_uploads_enabled':
'Od edycji 2021 uczestnicy przesyłają rozwiązania zadań kwalifikacyjnych przez stronę zamiast maila. Jeśli z jakiegoś powodu bardzo chcesz wyłączyć tą funkcję, skontaktuj się z organizatorami.',
'qualification_threshold':
'(wpisz dopiero po sprawdzeniu zadań)',
'max_points':
'(możesz postawić punkty bonusowe powyżej tej wartości, ale tylko do max. {}%)'
.format(settings.MAX_POINTS_PERCENT)
}
def __init__(self,
*args,
workshop_url,
has_perm_to_edit=True,
has_perm_to_disable_uploads=False,
profile_warnings=None,
**kwargs):
super(ModelForm, self).__init__(*args, **kwargs)
self.helper = FormHelper(self)
self.helper.include_media = False
# Disable fields that should be disabled
if not self.instance.is_workshop_editable() or not has_perm_to_edit:
for field in self.fields.values():
field.disabled = True
if self.instance.status:
# The proposition cannot be edited once the workshop has a status set
self.fields['proposition_description'].disabled = True
if not has_perm_to_disable_uploads:
self.fields['solution_uploads_enabled'].disabled = True
# Make sure only current category and type choices are displayed
if self.instance is None:
raise ValueError(
'WorkshopForm must be provided with an instance with the .year field already set'
)
year = self.instance.year
self.fields['category'].queryset = WorkshopCategory.objects.filter(
year=year)
self.fields['type'].queryset = WorkshopType.objects.filter(year=year)
# Display link to current qualification tasks:
if self.instance.qualification_problems:
self.fields['qualification_problems'].help_text = format_html(
'Aktualnie: <a href="{}" target="_blank">{}</a>',
reverse('qualification_problems',
args=[self.instance.year.pk, self.instance.name]),
os.path.basename(self.instance.qualification_problems.path))
else:
self.fields['qualification_problems'].help_text = 'Aktualnie: brak'
# Configure TinyMCE settings
mce_attrs = {}
mce_attrs['readonly'] = self.fields[
'proposition_description'].disabled # does not seem to respect the Django field settings for some reason
self.fields['proposition_description'].widget = InitializedTinyMCE(
mce_attrs=mce_attrs)
mce_attrs = settings.TINYMCE_DEFAULT_CONFIG_WITH_IMAGES.copy()
if self.instance and self.instance.pk:
mce_attrs['automatic_uploads'] = True
mce_attrs['images_upload_url'] = reverse('workshop_edit_upload',
kwargs={
'year':
self.instance.year.pk,
'name':
self.instance.name
})
mce_attrs['readonly'] = self.fields[
'page_content'].disabled # does not seem to respect the Django field settings for some reason
self.fields['page_content'].widget = InitializedTinyMCE(
mce_attrs=mce_attrs)
# Layout
self.fieldset_general = Fieldset(
"Ogólne",
Div(Div(PrependedAppendedText(
'name',
workshop_url[0] + '<b>' + str(year.pk) + '</b>' +
workshop_url[1],
workshop_url[2],
template=
"%s/layout/prepended_appended_text_with_mobile_support.html"),
css_class='col-lg-12'),
Div('title', css_class='col-lg-12'),
css_class='row'),
Div(Div('type', css_class='col-lg-6'),
Div('category', css_class='col-lg-6'),
css_class='row'),
)
if profile_warnings:
for message in profile_warnings:
self.fieldset_general.fields.append(
Alert(content=message,
dismiss=False,
css_class='alert-info'))
self.fieldset_proposal = Fieldset(
"Opis propozycji",
'proposition_description',
)
self.fieldset_qualification = Fieldset(
"Kwalifikacja",
'is_qualifying',
Div('qualification_problems',
Div(Div('max_points', css_class='col-lg-6'),
Div('qualification_threshold', css_class='col-lg-6'),
css_class='row'),
'solution_uploads_enabled',
css_id='qualification_settings'),
)
self.fieldset_public_page = Fieldset("Strona warsztatów",
'short_description',
'page_content',
'page_content_is_public')
self.fieldset_submit = FormActions(
StrictButton(
'Zapisz' if self.instance and self.instance.pk else 'Zgłoś!',
type='submit',
css_class='btn-outline-primary btn-lg mx-1 my-3'),
css_class='text-right',
)
if not self.instance or not self.instance.is_publicly_visible():
for field in [
'qualification_problems', 'is_qualifying',
'solution_uploads_enabled', 'max_points',
'qualification_threshold', 'short_description',
'page_content', 'page_content_is_public'
]:
del self.fields[field]
self.helper.layout = Layout(
self.fieldset_general,
self.fieldset_proposal,
self.fieldset_submit,
)
else:
if not has_perm_to_edit:
self.helper.layout = Layout(
self.fieldset_general,
self.fieldset_proposal,
self.fieldset_qualification,
self.fieldset_public_page,
)
else:
self.helper.layout = Layout(
self.fieldset_general,
self.fieldset_proposal,
self.fieldset_qualification,
self.fieldset_public_page,
self.fieldset_submit,
)
def clean(self):
super(WorkshopForm, self).clean()
if not self.instance.is_workshop_editable():
raise ValidationError(
'Nie można edytować warsztatów z poprzednich lat')
def validate_unique(self):
# Must remove year field from exclude in order
# for the unique_together constraint to be enforced.
exclude = self._get_validation_exclusions()
exclude.remove('year')
try:
self.instance.validate_unique(exclude=exclude)
except ValidationError as e:
self._update_errors(e.message_dict)
class Meta:
model = Person
fields = ["last_name", "first_name", "user"]
widgets = {"user": Select2Widget(attrs={"class": "browser-default"})}
class Meta:
model = Timesheet
fields = ('dockets', 'timesheet_date', 'week_start_date',
'week_end_date', 'docket_shift', 'equipment',
'equipment_num', 'company', 'project', 'start_time',
'finish_time', 'lunch', 'smoko', 'additional_info')
widgets = {
'docket':
forms.Select(attrs={
'id': 'docket_tag',
'class': 'form_control_timesheet form-control'
}),
'timesheet_date':
forms.DateInput(
attrs={
'id': 'docket_date_tag',
'class': 'form_control_timesheet form-control '
}),
'docket_shift':
forms.Select(
attrs={
'id': 'docket_shift_tag',
'class': 'form_control_timesheet form-control '
}),
'equipment':
Select2Widget(
attrs={
'id': 'equipment_name_tag',
'class': 'form_control_timesheet form-control'
}),
'equipment_num':
forms.TextInput(
attrs={
'id': 'equipment_num_tag',
'class': 'form_control_timesheet form-control '
}),
'start_time':
forms.TimeInput(
attrs={
'id': 'start_time_tag',
'class': 'form_control_timesheet form-control'
}),
'finish_time':
forms.TimeInput(
attrs={
'id': 'finish_time_tag',
'class': 'form_control_timesheet form-control'
}),
'lunch':
forms.Select(attrs={
'id': 'lunch_tag',
'class': 'form_control_timesheet form-control '
}),
'smoko':
forms.Select(attrs={
'id': 'smoko_tag',
'class': 'form_control_timesheet form-control '
}),
'additional_info':
forms.Textarea(
attrs={
'id': 'additional_info_tag',
'class': 'form_control_timesheet form-control '
}),
}
class Meta:
exclude = 'quantity', 'product_component', 'equipment_component',
model = models.InventoryItem
widgets = {'supplier': Select2Widget(attrs={'data-width': '24rem'})}
class Meta:
exclude = "maximum_stock_level", "minimum_order_level", "product_component", "equipment_component",
model = models.InventoryItem
widgets = {'supplier': Select2Widget(attrs={'data-width': '24rem'})}
class ManageActiveGroupMeetingsForm(ModelForm):
member = forms.ModelChoiceField(
widget=Select2Widget(), queryset=ElecteeGroup.get_current_leaders())
amount_completed = forms.IntegerField(min_value=0, label='Team Meetings')
class Meta:
model = ProgressItem
fields = ['member', 'amount_completed']
def __init__(self, *args, **kwargs):
extra_amt = 0
instance = kwargs.get('instance', None)
initial = kwargs.get('initial', {})
init_val = int(0)
if instance:
extra_meetings = ProgressItem.objects.filter(
term=AcademicTerm.get_current_term(),
member=instance.member,
event_type__name='Extra Team Meetings',
)
if extra_meetings.exists():
extra_amt = extra_meetings.aggregate(Sum('amount_completed'))
extra_amt = extra_amt['amount_completed__sum']
init_val = int(instance.amount_completed + extra_amt)
initial['amount_completed'] = init_val
kwargs['initial'] = initial
super(ManageActiveGroupMeetingsForm, self).__init__(*args, **kwargs)
def save(self, commit=True):
instance = super(ManageActiveGroupMeetingsForm,
self).save(commit=False)
term = AcademicTerm.get_current_term()
instance.term = term
instance.date_completed = date.today()
instance.name = 'Team Meetings'
extra_meetings = ProgressItem.objects.filter(
term=term,
member=instance.member,
event_type__name='Extra Team Meetings',
)
group = ElecteeGroup.objects.filter(
Q(leaders=instance.member) | Q(officers=instance.member))
group = group.filter(term=term)
dist = DistinctionType.objects.filter(
status_type__name='Electee', standing_type__name='Undergraduate')
if group.exists():
print group
if group[0].members.exists():
print group[0]
standing = group[0].members.all()[0].standing
dist = DistinctionType.objects.filter(
status_type__name='Electee', standing_type=standing)
group_meeting_req = Requirement.objects.filter(
distinction_type=dist,
event_category__name='Team Meetings',
term=term.semester_type)
if group_meeting_req:
amount_group_req = group_meeting_req[0].amount_required
else:
amount_group_req = 0
if extra_meetings.count(
) > 1 or instance.amount_completed <= amount_group_req:
extra_meetings.delete()
if not extra_meetings.exists(
) and instance.amount_completed > amount_group_req:
extra_meeting = ProgressItem(term=term,
member=instance.member,
date_completed=date.today())
extra_meeting.event_type = EventCategory.objects.get(
name='Extra Team Meetings')
extra_meeting.amount_completed = instance.amount_completed - amount_group_req
extra_meeting.save()
elif instance.amount_completed > amount_group_req:
extra_meeting = extra_meetings[0]
extra_meeting.amount_completed = instance.amount_completed - amount_group_req
extra_meeting.save()
instance.event_type = EventCategory.objects.get(name='Team Meetings')
if instance.amount_completed > amount_group_req:
instance.amount_completed = amount_group_req
if commit:
instance.save()
return instance
class WidgetSelectForm(SelfHandlingForm):
cls_name = forms.ChoiceField(label=_("Widget Type"),
choices=[],
required=True,
widget=Select2Widget())
first = forms.BooleanField(label=_('First ?'),
help_text=_(
'If is checked, widget will be'
' placed as first widget in this region'),
initial=False,
required=False)
page_id = forms.IntegerField(widget=forms.widgets.HiddenInput, )
ordering = forms.IntegerField(widget=forms.widgets.HiddenInput, initial=99)
region = forms.ChoiceField(label=_('Region'), widget=Select2Widget())
parent = forms.IntegerField(widget=forms.widgets.HiddenInput, )
def __init__(self, *args, **kwargs):
request = kwargs.pop('request', None)
page_id = kwargs.pop('page_id', None)
region_name = kwargs.pop('region', None)
feincms_cls_name = kwargs.pop('cls_name', None)
self.next_view = kwargs.pop('next_view', None)
module, cls = feincms_cls_name.split('.')
ObjectCls = apps.get_model(module, cls)
feincms_object = ObjectCls.objects.get(id=page_id)
super(WidgetSelectForm, self).__init__(*args, **kwargs)
self.fields['page_id'].initial = feincms_object.id
self.fields['region'].initial = region_name
# load template regions
self.fields['region'].choices = \
[(str(region.key),
'%s%s' % (
str(region.title),
_(' - Inherited') if region.inherited else ''))
for region in feincms_object.template.regions]
if region_name:
self.fields['ordering'].initial = \
len(getattr(feincms_object.content, region_name, [])) + 1
self.fields['parent'].initial = feincms_object.id
choices, grouped, ungrouped = get_grouped_widgets(
feincms_object, request)
# reduce choices for validation
self.fields['cls_name'].choices = [(str(choice[0]), str(choice[1]))
for choice in choices]
# for now ungrouped to grouped
grouped['Web'] = ungrouped + grouped.get('Web', [])
self.helper.layout = Layout(
Field('parent'),
Field('page_id'),
Field('ordering'),
'cls_name',
Field('region'),
Field('first'),
)
def handle(self, request, data):
# NOTE (majklk): This is a bit of a hack, essentially rewriting this
# request so that we can chain it as an input to the next view...
# but hey, it totally works.
request.method = 'GET'
first = data.pop('first', None)
if first:
data['ordering'] = 0
return self.next_view.as_view()(request, **data)
class Meta:
model = ModuleHECoSSubject
fields = ['hecos_subject', 'percentage']
widgets = {'hecos_subject': Select2Widget()}
def test_js_setting(self, settings):
settings.SELECT2_JS = "alternate.js"
sut = Select2Widget()
result = sut.media.render()
assert "alternate.js" in result
assert "django_select2/django_select2.js" in result
class Meta:
model = models.Module
fields = [
'code',
'title',
'url',
'division',
'portfolio',
'format',
'phone',
'email',
'subjects',
'marketing_types',
'non_credit_bearing',
'default_non_credit',
'start_date',
'end_date',
'start_time',
'end_time',
'meeting_time',
'open_date',
'closed_date',
'publish_date',
'unpublish_date',
'location',
'room',
'room_setup',
'max_size',
'single_places',
'twin_places',
'address',
'no_meetings',
'week_number',
'cost_centre',
'activity_code',
'source_of_funds',
'custom_fee',
'snippet',
'notification',
'overview',
'programme_details',
'selection_criteria',
'course_aims',
'certification',
'assessment_methods',
'it_requirements',
'level_and_demands',
'recommended_reading',
'teaching_methods',
'teaching_outcomes',
'accommodation',
'payment',
'scholarships',
'how_to_apply',
'further_details',
'terms_and_conditions',
'enrol_online',
'apply_url',
'no_search',
'mailing_list',
'image',
'credit_points',
'points_level',
'note',
'direct_enrolment',
]
widgets = {
'closed_date':
widgets.DateTimePickerInput(),
'subjects':
Select2MultipleWidget(),
'marketing_types':
Select2MultipleWidget(),
'non_credit_bearing':
widgets.ToggleWidget(
attrs={
'data-on': 'Non-credit',
'data-off': 'For credit',
'data-onstyle': 'warning',
'data-offstyle': 'success',
}),
'default_non_credit':
widgets.ToggleWidget(
attrs={
'data-on': 'Non-credit',
'data-off': 'For credit',
'data-offstyle': 'success',
'data-onstyle': 'warning',
}),
'enrol_online':
widgets.ToggleWidget(attrs={
'data-on': 'Allowed',
'data-off': 'Not allowed'
}),
'direct_enrolment':
widgets.ToggleWidget(attrs={
'data-on': 'Allowed',
'data-off': 'Not allowed'
}),
'note':
Textarea(),
'notification':
CKEditorWidget(config_name='links_only'),
**{field: CKEditorUploadingWidget()
for field in HTML_FIELDS},
**{field: widgets.DatePickerInput()
for field in DATE_FIELDS},
'start_time':
widgets.TimePickerInput(),
'end_time':
widgets.TimePickerInput(),
'location':
Select2Widget(),
}
def test_custom_tag_attrs_Select2Widget(self):
widget = Select2Widget(attrs={"data-minimum-input-length": "3"})
output = widget.render("name", "value")
assert 'data-minimum-input-length="3"' in output
class Meta:
if use_select2:
widgets = {
'contest': Select2Widget(),
'profile': HeavySelect2Widget(data_view='contest_profile_select2'),
}
def form_members(self):
experience = forms.ChoiceField(choices=Juror.EXPERIENCES, required=False,
widget=Select2Widget())
return {"experience":experience}
'pasteInline': ['strong', 'b', 'i', 'em'],
'minHeight': 75,
}
DEFAULT_FORMFIELD_OVERRIDES = {
models.ManyToManyField: {
'widget':
Select2MultipleWidget(attrs={
'data-placeholder': 'Ninguno',
'data-minimum-results-for-search': 10
})
},
models.ForeignKey: {
'widget':
Select2Widget(attrs={
'data-placeholder': 'Ninguno',
'data-minimum-results-for-search': 10
})
},
ImageField: {
'widget': AdminImageWidget
},
# models.DateTimeField: {
# 'widget': SuitSplitDateTimeWidget
# },
models.DateField: {
'widget': SuitDateWidget
},
models.TextField: {
'widget':
AutosizedTextarea(attrs={
'rows': 5,
class HealerSearchForm(forms.Form):
'''
modality = forms.CharField(max_length=50, label="Type", required=False,
widget=forms.TextInput(attrs={
'placeholder': 'Specialty (optional)',
'id': 'healer_modality_input',
'class': 'modality_input'
}))
'''
search_city_or_zipcode = forms.CharField(
max_length=50,
label="City",
required=False,
widget=forms.TextInput(attrs={
'placeholder': 'City or Town',
'class': 'search_city_or_zipcode'
}))
zipcode = forms.CharField(
required=False, widget=forms.HiddenInput(attrs={'class': 'zipcode'}))
city = forms.CharField(max_length=50,
required=False,
widget=forms.HiddenInput())
state = forms.CharField(max_length=2,
required=False,
widget=forms.HiddenInput())
modality_id = forms.IntegerField(
required=False,
widget=forms.HiddenInput(attrs={'id': 'modality_id_hidden'}))
modality_category_id = forms.IntegerField(
required=False,
widget=forms.HiddenInput(attrs={'id': 'modality_category_id_hidden'}))
name_or_email = forms.CharField(
required=False,
max_length=75,
label="Provider Name",
widget=forms.TextInput(
attrs={
'size': 25,
'maxlength': 75,
'placeholder': 'Provider Name or Email'
# 'id': ''
}))
modality2 = forms.ChoiceField(
required=False,
widget=Select2Widget(attrs={'data-placeholder': 'Any Specialty'}),
#[ ('', 'Any Specialty') ] +
choices=categories_as_choices())
modality3 = forms.ChoiceField(
required=False,
widget=Select2Widget(attrs={'data-placeholder': 'Any Specialty'}),
#[ ('', 'Any Specialty') ] +
choices=categories_as_choices())
order_by_top = forms.BooleanField(required=False,
widget=forms.HiddenInput())
def __init__(self, *args, **kwargs):
self.city_or_zipcode_placeholder = kwargs.pop(
'city_or_zipcode_placeholder', 'City')
super(HealerSearchForm, self).__init__(*args, **kwargs)
def get_zipcode(self):
if self.cleaned_data.get('city', False):
try:
return Zipcode.objects.filter(
city=self.cleaned_data['city'].upper(),
state=self.cleaned_data['state'])[:1][0]
except (Zipcode.DoesNotExist, IndexError):
return
elif self.cleaned_data.get('zipcode', False):
try:
return Zipcode.objects.get(code=self.cleaned_data['zipcode'])
except Zipcode.DoesNotExist:
return
def parse_params(self, request):
trn = request.user.profile.tournament
self.filters = [
{
"name": "Roles",
"filter": "roles__in",
"elements": trn.participationrole_set.all()
},
{
'name': "Groups",
"elements": trn.groups.all(),
"filter": "groups__in"
},
{
'name': "Team",
"elements": trn.team_set.all(),
"filter": "team__in"
},
]
self._filters = {}
self._excludes = {}
for fname in [x['filter'] for x in self.filters]:
try:
inarg = request.GET.getlist("in_%s" % fname, None)
if len(inarg) > 0:
self._filters[fname] = list(map(int, inarg))
exarg = request.GET.getlist("ex_%s" % fname, None)
if len(exarg) > 0:
self._excludes[fname] = list(map(int, exarg))
except:
pass
ex_query = Q()
for k in self._excludes:
ex_query |= Q(**{k: self._excludes[k]})
person = ModelDeleteListField(
queryset=Attendee.objects.filter(tournament=trn, **self._filters).
exclude(ex_query).order_by("active_user__user__last_name").
prefetch_related('roles', 'groups', 'active_user__user',
'teammember_set__team__origin'))
allowedros = [
r.id for r in trn.participationrole_set.all()
if _more_perm_than_role(request.user, r)
]
roles = forms.ModelMultipleChoiceField(
queryset=ParticipationRole.objects.filter(id__in=allowedros),
required=False,
widget=Select2MultipleWidget())
allowedgrs = [
gr.id for gr in trn.groups.all()
if _more_perm_than_group(request.user, gr)
]
groups = forms.ModelMultipleChoiceField(
queryset=Group.objects.filter(id__in=allowedgrs),
required=False,
widget=Select2MultipleWidget())
team = forms.ModelChoiceField(
queryset=Team.objects.filter(tournament=trn),
required=False,
widget=Select2Widget())
template = forms.ModelChoiceField(
queryset=trn.template_set.filter(type=Template.PERSONS),
required=False,
widget=Select2Widget())
conflicting = forms.ModelChoiceField(
queryset=trn.attendeeproperty_set.filter(
type=AttendeeProperty.CONFLICT_ORIGINS),
required=False,
widget=Select2Widget)
self.form = type(
"PersonsForm", (forms.Form, ), {
'persons': person,
'roles': roles,
'groups': groups,
"template": template,
"team": team,
"conflicting": conflicting
})
def test_css_setting(self, settings):
settings.SELECT2_CSS = 'alternate.css'
sut = Select2Widget()
result = sut.media.render()
assert 'alternate.css' in result
class AddProjectReportForm(Form):
"""
A form for selecting a project report to associate with a particular event.
"""
report = forms.ModelChoiceField(widget=Select2Widget(),
queryset=ProjectReport.objects.all())
def test_tag_attrs_Select2Widget(self):
widget = Select2Widget()
output = widget.render('name', 'value')
assert 'data-minimum-input-length="0"' in output
class BaseEventForm(ModelForm):
"""
Form used in creating or editing event objects. This only creates the event
itself, not the shifts, though the formset for creating those is often
paired with this.
"""
TWEET_CHOICES = (
('N', 'No Tweet'),
('T', 'Tweet normally'),
('H', 'Tweet with #UmichEngin'),
)
leaders = forms.ModelMultipleChoiceField(
widget=Select2MultipleWidget(), queryset=MemberProfile.get_members())
tweet_option = forms.ChoiceField(choices=TWEET_CHOICES, initial='N')
agenda = forms.ModelChoiceField(
widget=Select2Widget(),
queryset=MeetingMinutes.objects.filter(
semester=AcademicTerm.get_current_term(),
meeting_type__in=['NI', 'MM']),
required=False,
)
class Meta:
model = CalendarEvent
fields = [
'name',
'term',
'event_type',
'event_class',
'description',
'agenda',
'google_cal',
'leaders',
'assoc_officer',
'announce_start',
'announce_text',
'preferred_items',
'min_unsign_up_notice',
'min_sign_up_notice',
'members_only',
'needs_carpool',
'use_sign_in',
'allow_advance_sign_up',
'needs_facebook_event',
'needs_flyer',
'requires_UM_background_check',
'requires_AAPS_background_check',
'mutually_exclusive_shifts',
'allow_overlapping_sign_ups',
'needs_COE_event',
]
def clean(self):
"""
Ensures that tweets are not sent or COE events not created for events
which are marked as members-only
"""
cleaned_data = super(BaseEventForm, self).clean()
members_only = cleaned_data.get('members_only')
tweet_option = cleaned_data.get('tweet_option')
coe_option = cleaned_data.get('needs_COE_event')
if members_only and not tweet_option == 'N':
raise ValidationError(
_('Tweeting is not currentlys supported'
' for members-only events'))
if members_only and coe_option:
raise ValidationError(
_('Members-only events cannot be on the'
' COE Calendar.'))
return cleaned_data
def test_default_media(self):
sut = Select2Widget()
result = sut.media.render()
assert f'//cdnjs.cloudflare.com/ajax/libs/select2/{settings.SELECT2_LIB_VERSION}/js/select2.min.js' in result
assert f'//cdnjs.cloudflare.com/ajax/libs/select2/{settings.SELECT2_LIB_VERSION}/css/select2.min.css' in result
assert 'django_select2/django_select2.js' in result
class Meta:
model = ProtocoloLondres
fields = ('cronologia', 'acciones_inseguras', 'factores_ambiental',
'factores_equipo', 'responsable', 'fecha_solucion',
'factores_individuo', 'factores_institucional',
'factores_organizacion', 'factores_paciente',
'factores_tecnologia', 'actividades', 'seguimiento')
widgets = {
'cronologia':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'acciones_inseguras':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_ambiental':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_equipo':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_individuo':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_institucional':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_organizacion':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_paciente':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'factores_tecnologia':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'actividades':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
'seguimiento':
forms.Textarea(attrs={
'rows': 5,
'style': 'resize:none;'
}),
# "fecha_solucion": forms.SelectDateWidget,
"empleado":
Select2Widget(),
}
labels = {
'cronologia': "Cronología",
'acciones_inseguras': "Acciones inseguras",
'factores_ambiental':
"Factores contributivos relacionados con el ambiente",
'factores_equipo':
"Factores contributivos relacionados con el equipo de trabajo",
'factores_individuo':
"Factores contributivos relacionados con el individuo",
'factores_institucional':
"Factores relacionados con el contexto institucional",
'factores_organizacion':
"Factores contributivos relacionados con organización y gerencia",
'factores_paciente':
"Factores contributivos relacionados con el paciente",
'factores_tecnologia':
"Factores contributivos relacionados con la Tarea y Tecnología",
'actividades': "Actividades",
'seguimiento': "Seguimiento",
'responsable': "Responsable de realizar el protocolo",
'fecha_solucion': "Fecha creación del protocolo"
}
