class LearningUnitYearForExternalModelForm(LearningUnitYearModelForm):
country_external_institution = ModelChoiceField(
queryset=Country.objects.all(),
required=False,
label=_("Country"),
widget=autocomplete.ModelSelect2(url='country-autocomplete'))
def __init__(self, *args, instance=None, initial=None, **kwargs):
super().__init__(*args,
instance=instance,
initial=initial,
external=True,
**kwargs)
self.fields['internship_subtype'].disabled = True
if instance:
self.fields["country_external_institution"].initial = instance.campus.organization.country and \
instance.campus.organization.country.pk
elif initial.get("campus"):
self.fields["country_external_institution"].initial = initial["campus"].organization.country and\
initial["campus"].organization.country.pk
if not instance:
self.data['acronym_0'] = LearningUnitExternalSite.E.value
class Meta(LearningUnitYearModelForm.Meta):
fields = ('academic_year', 'acronym', 'specific_title',
'specific_title_english', 'credits', 'session',
'quadrimester', 'status', 'internship_subtype',
'attribution_procedure', 'professional_integration',
'campus', 'language', 'periodicity')
widgets = {
'campus':
autocomplete.ModelSelect2(url='campus-autocomplete',
forward=["country_external_institution"
]),
'credits':
forms.TextInput(),
}
labels = {'campus': _("Reference institution")}
def __init__(self, *args, **kwargs):
make = kwargs.pop('make')
years = kwargs.pop('years')
body_type = kwargs.pop('body_type')
if str(years)[-3:] == " ??":
max_year = timezone.now().year
min_year = 1970
else:
if not "_" in str(years)[-4:] and not "?" in str(years)[-4:]:
max_year = int(str(years)[-4:])
else:
max_year = timezone.now().year
if not "?" in str(years)[:-5]:
if not "?" in str(years)[-4:]:
min_year = int(str(years)[-10:-5])
else:
min_year = int(str(years)[-8:-3])
else:
min_year = 1970
super(ListingForm, self).__init__(*args, **kwargs)
year_choices = [(x, x) for x in range(min_year, max_year + 1)]
self.fields['year'].choices = year_choices
if len(Car.objects.filter(make=make, years=years,
body_type=body_type)) == 1:
self.fields['car'] = ModelChoiceField(
queryset=Car.objects.filter(make=make,
years=years,
body_type=body_type),
initial={'make': make},
widget=forms.Select(attrs={'class': 'form-control'}))
else:
self.fields['car'] = MyModelChoiceField(
queryset=Car.objects.filter(make=make,
years=years,
body_type=body_type),
initial={'make': make},
widget=forms.Select(attrs={'class': 'form-control'}))
class TopicForm(ModelForm):
required = (
'title',
'meeting',
'description',
)
meeting = ModelChoiceField(queryset=Meeting.objects.filter(
when__gt=datetime.datetime.now()))
def __init__(self, request, *args, **kwargs):
super(TopicForm, self).__init__(*args, **kwargs)
self.fields['meeting'].required = True
self.fields['description'].required = True
self.request = request
class Meta:
model = Topic
fields = (
'title',
'meeting',
'length',
'description',
'slides_link',
)
def save(self, commit=True):
instance = super(TopicForm, self).save(commit)
if self.request and not instance.presentor:
instance.presentor, created = Presentor.objects.get_or_create(
user=self.request.user,
name=self.request.user.get_full_name(),
email=self.request.user.email,
release=True,
)
if commit:
instance.save()
return instance
def quiz_add(request, course_id, template_name):
"""
Render add new quiz page and handle POST requests
"""
try:
course = Course.objects.get(id=course_id)
except Course.DoesNotExist:
course = None
if request.method == 'POST':
form = AddQuizForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
form.user = request.user
form.course = course
form.save()
try:
quiz = Quiz.objects.get(id=form.id)
except Quiz.DoesNotExist:
return HttpResponseRedirect(
reverse('quiz_add', args=[course.id]))
return HttpResponseRedirect(
reverse('mcquestion_add', args=[quiz.id]))
else:
return render_to_response(template_name,
context_instance=RequestContext(
request, {
'form': form,
'course': course,
'course_id': course_id
}))
else:
AddQuizForm.base_fields['video'] = ModelChoiceField(
queryset=UploadedFile.objects.filter(file_type='VID'))
form = AddQuizForm()
return render_to_response(template_name,
context_instance=RequestContext(
request, {
'form': form,
'course_id': course.id
}))
class UploadDatasetsModelForm(BSModalModelForm):
owner = ModelChoiceField(queryset=User.objects.all(),
required=True,
widget=Select(attrs={"class": "form-select"}))
files = FileField(widget=ClearableFileInput(attrs={"multiple": True}))
class Meta:
model = Dataset
fields = ["tags", "contacts", "owner"]
widgets = {
"tags":
TextInput(attrs={"placeholder": "Comma-separated"}),
"contacts":
SelectMultiple(attrs={
"class": "selectpicker",
"multiple": "on"
}),
}
def get_grouped_fields(self):
"""Grouping fields for easier handling in the template."""
return [[self["tags"], self["contacts"]], [self["owner"]]]
class ScheduleBasicForm(ModelForm):
required_css_class = 'required'
error_css_class = 'error'
day = ChoiceField(choices=['No Days Specified'])
time = ChoiceField(choices=conference_times)
location = ModelChoiceField(queryset=Room.objects.all().order_by('name'))
max_volunteer = IntegerField(required=True)
duration = FloatField(min_value=0.5, max_value=12, required=True)
class Meta:
model = Event
fields = [
'e_title',
'e_description',
'duration',
'max_volunteer',
'day',
'time',
'location',
]
def __init__(self, *args, **kwargs):
if 'instance' in kwargs:
conference = kwargs['instance'].e_conference
if 'initial' in kwargs and 'duration' not in kwargs['initial']:
kwargs['initial']['duration'] = float(
kwargs['instance'].duration.total_seconds()) / 3600
else:
conference = kwargs.pop('conference')
super(ScheduleBasicForm, self).__init__(*args, **kwargs)
self.fields['day'] = ModelChoiceField(
queryset=conference.conferenceday_set.all())
self.fields['location'] = ModelChoiceField(
queryset=Room.objects.filter(conferences=conference))
def clean_duration(self):
data = timedelta(minutes=self.cleaned_data['duration'] * 60)
return data
class SejourSearchForm(Form):
date_debut_min = DateField(label="Date de début du séjour entre le",
required=False,
widget=DateInput())
date_debut_max = DateField(label=" et le ",
required=False,
widget=DateInput())
date_fin_min = DateField(label="Date de fin du séjour entre le",
required=False,
widget=DateInput())
date_fin_max = DateField(label=" et le ",
required=False,
widget=DateInput())
proprietaire = ModelChoiceField(
queryset=Proprietaire.objects.all().filter(inactif=False),
required=False)
cohabitation = ChoiceField(
choices=BLANK_CHOICE_DASH + [(tag.name, tag.value)
for tag in OuiNonChoice],
widget=Select(),
required=False,
)
class Meta:
model = models.Contact
contact_cinema = ModelChoiceField(queryset=models.Cinema.objects.all(), empty_label=None, to_field_name="cinema_name")
fields = ['contact_cinema', 'contact_address', 'contact_location', 'contact_logo', 'status']
widgets = {
'contact_address': Textarea(attrs={
'class': 'form-control',
'id': 'ContactAddressInput',
'rows': '5',
'placeholder': 'Введите адрес кинотеатра',
}),
'contact_location': AddressWithMapWidget(attrs={
'class': 'form-control',
'placeholder': 'Введите координаты карты',
'id': 'ContactCoordInput',
}),
'contact_logo': FileInput(attrs={
'class': 'upload',
'id': 'ContactMainImage',
})
}
class BreakfastForm(ModelForm):
"""Form for creating a new assignment for a course."""
participant = ModelChoiceField(
queryset=Participant.objects.filter(is_active=True),
empty_label=None,
help_text=_('Participant that has to pay'))
class Meta:
model = Breakfast
widgets = {
"date":
DateInput(attrs={
'class': 'form-control',
'placeholder': 'YYYY-MM-DD'
})
}
help_texts = {
'date': _('The date has to be in the future'),
}
fields = ['date', 'participant']
class LayerForm(forms.ModelForm):
urlModels = ModelChoiceField(
label='Annotation Layer',
queryset=UrlModel.objects.filter(
vetted=True).all().order_by('comments'),
required=True,
widget=forms.Select(attrs={
'onchange': 'layerdata_form.submit();',
'class': 'form-control'
}))
class Meta:
model = UrlModel
exclude = [
'prep', 'structure', 'person', 'url', 'transformation',
'input_type', 'x', 'y', 'section', 'active'
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#self.fields['layer'].queryset = LayerData.objects.all()
self.fields['layer'].options = {'one': 1, 'two': 2}
class CreateNewsletterForm(ModelForm):
subject = CharField(required=True, label='Onderwerp')
template = ModelChoiceField(
queryset=models.NewsletterTemplate.objects.filter().order_by('title'),
required=True,
widget=RadioSelect,
empty_label=None,
label='Template')
events = EventField(queryset=get_upcoming_events(),
required=False,
widget=CheckboxSelectMultiple,
label='Events')
class Meta(object):
model = models.Newsletter
fields = ['subject', 'template', 'events']
def __init__(self, *args, **kwargs):
super(CreateNewsletterForm, self).__init__(*args, **kwargs)
self.fields['events'].widget.attrs['class'] = 'checkboxlist'
class UserEditForm(CremeModelForm):
role = ModelChoiceField(label=_('Role'),
queryset=UserRole.objects.all(),
required=False)
class Meta:
model = CremeUser
fields = ('first_name', 'last_name', 'email', 'role') # 'is_superuser'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# NB: browser can ignore <em> tag in <option>...
self.fields['role'].empty_label = '*{}*'.format(gettext('Superuser'))
def save(self, *args, **kwargs):
instance = self.instance
# NB: needed with django 1.8 when we reset to 'None' (the value seems skipped) => is it a bug ??
instance.role = role = self.cleaned_data['role']
instance.is_superuser = (role is None)
return super().save(*args, **kwargs)
class ReidentifySpeciesForm(forms.ModelForm):
gen = ModelChoiceField(
queryset=Genus.objects.filter(num_hybrid__gt=0).values_list('pid', 'genus'),
required=True,
widget=Select2Widget
)
# gen = forms.ChoiceField(required=True,
# choices=Genus.objects.filter(num_hybrid__gt=0).values_list('pid', 'genus'))
pid = forms.ChoiceField(required=True,
choices=Accepted.objects.values_list('pid'))
def __init__(self,*args,**kwargs):
super(ReidentifySpeciesForm, self).__init__(*args, **kwargs)
# self.fields['gen'].required = True
# self.fields['pid'].required = True
# self.fields['pid'].queryset = Accepted.objects.none()
# self.fields['gen'].queryset = Genus.objects.filter(num_hybrid__gt=0)
if 'gen' in self.data:
try:
gen = int(self.data.get('gen'))
self.fields['pid'].queryset = Accepted.objects.filter(gen=gen).order_by('species')
except (ValueError, TypeError):
pass # invalid input from the client; ignore and fallback to empty City queryset
elif self.instance.pk:
self.fields['pid'].queryset = self.instance.gen.pid_set #.order_by('name')
class Meta:
model = SpcImages
fields = ('gen','pid')
labels = {
'gen':'Genus',
'pid':'Species',
}
widgets = {
# 'pid': forms.HiddenInput(),
# 'gen': TextInput(attrs={'size': 50, 'style': 'font-size: 13px',}),
'species': TextInput(attrs={'size': 50, 'style': 'font-size: 13px',}),
'infraspr': TextInput(attrs={'size': 50, 'style': 'font-size: 13px',}),
'infraspe': TextInput(attrs={'size': 50, 'style': 'font-size: 13px',}),
}
class Edit(Form):
name = CharField(label=_("NAME"))
active = BooleanField(label=_("ACTIVE"), initial=True, required=False)
reserve = BooleanField(label=_("RESERVE"), initial=False, required=False)
station = ModelChoiceField(label=_("STATION"), queryset=None, required=True)
lockcode = CharField(label=_("LOCKCODE"))
size = ChoiceField(choices=SIZE_CHOICES, label=_("SIZE"), initial="MEDIUM")
lights = BooleanField(label=_("LIGHTS"), initial=False, required=False)
description = CharField(label=_("DESCRIPTION"), widget=Textarea)
def __init__(self, *args, **kwargs):
self.bike = kwargs.pop("bike")
self.account = kwargs.pop("account")
super(Edit, self).__init__(*args, **kwargs)
self.fields["name"].initial = self.bike.name
self.fields["active"].initial = self.bike.active
self.fields["reserve"].initial = self.bike.reserve
self.fields["station"].queryset = self.bike.team.stations.filter(active=True)
self.fields["station"].initial = self.bike.station
self.fields["lockcode"].initial = self.bike.lockcode
self.fields["size"].initial = self.bike.size
self.fields["lights"].initial = self.bike.lights
self.fields["description"].initial = self.bike.description
def clean(self):
cleaned_data = super(Edit, self).clean()
station = cleaned_data.get("station")
active = cleaned_data.get("active")
if (not active and self.bike.active and
not control.can_deactivate(self.account, self.bike)):
raise ValidationError(_("ERROR_CANNOT_DEACTIVATE_BIKE_IN_USE"))
if (station and station != self.bike.station and
not control.can_change_station(self.account, self.bike, station)):
raise ValidationError(_("ERROR_CANNOT_CHANGE_STATION_BIKE_IN_USE"))
return cleaned_data
def __init__(self, *args, poll, **kwargs):
super().__init__(*args, **kwargs)
self.poll = poll
self.helper = FormHelper()
if 'options' in self.poll.rules and self.poll.rules['options'] == 1:
self.fields['choice'] = ModelChoiceField(
label='Choix',
queryset=poll.options.all().order_by('?'),
widget=RadioSelect,
required=True,
empty_label=None,
initial=None,
)
else:
self.fields['choice'] = ModelMultipleChoiceField(
label='Choix',
queryset=poll.options.all().order_by('?'),
widget=CheckboxSelectMultiple(),
)
self.helper.add_input(Submit('submit', 'Confirmer'))
class CustomerForm(forms.ModelForm):
sale_manager = ModelChoiceField(queryset=s_manager, required=True)
class Meta:
model = Customer
fields = (
'name',
'customer_code',
'sale_manager',
'status',
'address',
'pincode',
'country',
'city',
'state',
'area',
'status',
'lattitude',
'longitude',
'email',
'mobile',
)
class AddPortionForm(Form):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_show_labels = False
food = ModelChoiceField(queryset=Food.objects.all().order_by('name'),
empty_label='choose food',
widget=Select(attrs={'class': "form-control"}))
weight = IntegerField(min_value=1, max_value=9999,
widget=NumberInput(attrs={'class': "form-control", 'placeholder': "grams"}))
# TODO check why its not needed, probably its default for formset (for only one of two fields filled)
# def clean_food(self):
# return check_not_empty(self, filed_name='food')
#
# def clean_weight(self):
# return check_not_empty(self, filed_name='weight')
def is_fullfilled(self):
return len(self.cleaned_data) == len(self.fields)
class ArchiveCasesToReaderStudyForm(SaveFormInitMixin, Form):
reader_study = ModelChoiceField(
queryset=ReaderStudy.objects.none(),
required=True,
)
images = ModelMultipleChoiceField(
queryset=Image.objects.none(),
required=True,
widget=Select2MultipleWidget,
)
def __init__(self, *args, user, archive, **kwargs):
super().__init__(*args, **kwargs)
self.user = user
self.archive = archive
self.fields["reader_study"].queryset = get_objects_for_user(
self.user,
"reader_studies.change_readerstudy",
accept_global_perms=False,
).order_by("title")
self.fields["images"].queryset = Image.objects.filter(
componentinterfacevalue__archive_items__archive=self.archive
).distinct()
self.fields["images"].initial = self.fields["images"].queryset
def clean(self):
cleaned_data = super().clean()
cleaned_data["images"] = cleaned_data["images"].exclude(
readerstudies__in=[cleaned_data["reader_study"]])
if len(cleaned_data["images"]) == 0:
raise ValidationError(
"All of the selected images already exist in that reader study"
)
return cleaned_data
class Form(ModelForm):
class Meta:
model = Alias
fields = '__all__'
owner = ModelChoiceField(
queryset=Membership.objects.filter(pk=alias.owner.id),
empty_label=None)
@staticmethod
def clean_name():
return alias.name
@staticmethod
def clean_owner():
return alias.owner
def disable_fields(self):
self.fields['name'].required = False
self.fields['name'].widget.attrs['readonly'] = 'readonly'
self.fields['owner'].required = False
self.fields['owner'].widget.attrs['readonly'] = 'readonly'
def __init__(self, *args, poll, **kwargs):
super().__init__(*args, **kwargs)
self.poll = poll
self.helper = FormHelper()
if "options" in self.poll.rules and self.poll.rules["options"] == 1:
self.fields["choice"] = ModelChoiceField(
label="Choix",
queryset=poll.options.all().order_by("?"),
widget=RadioSelect,
required=True,
empty_label=None,
initial=None,
)
else:
self.fields["choice"] = ModelMultipleChoiceField(
label="Choix",
queryset=poll.options.all().order_by("?"),
widget=CheckboxSelectMultiple(),
)
self.helper.add_input(Submit("submit", "Confirmer"))
class IconFormMixin(EntangledModelFormMixin):
icon_font = ModelChoiceField(
IconFont.objects.all(),
label=_("Font"),
initial=get_default_icon_font,
)
symbol = CharField(
widget=widgets.HiddenInput(),
label=_("Select Symbol"),
)
class Meta:
entangled_fields = {'glossary': ['icon_font', 'symbol']}
def __init__(self, *args, **kwargs):
if not getattr(self, 'require_icon', True):
self.declared_fields['icon_font'].required = False
self.declared_fields['icon_font'].empty_label = _("No Icon")
self.declared_fields['icon_font'].initial = None
self.declared_fields['symbol'].required = False
super().__init__(*args, **kwargs)
class DownloadSamplesheetButton(forms.Form):
"""
Button to download samplesheet. Renders in an alert box which changes coour depending on the status
of the samplesheet checks - green if complete and red if not
"""
additional_worksheet = ModelChoiceField(queryset=Worksheet.objects.filter(
clinsci_signoff_complete=True,
techteam_signoff_complete=True).order_by('-worksheet_id'),
required=False,
label="Available worksheets")
def __init__(self, *args, **kwargs):
# get variable from view - whether or not all checks are complete
self.checks_complete = kwargs.pop('checks_complete')
super(DownloadSamplesheetButton, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_method = 'POST'
# render form differently depending on whether or not the checks are complete
if self.checks_complete:
message = '<span class="fa fa-check-circle" style="width:20px;color:green"></span>Samplesheet has been checked.'
message_class = 'success'
else:
message = '<span class="fa fa-times-circle" style="width:20px;color:red"></span>The checks are not complete.'
message_class = 'danger disabled'
# make layout
self.helper.layout = Layout(
Div(Field('additional_worksheet'),
Div(Div(HTML(f'{message}'), css_class='col-8'),
Div(StrictButton(
'<span class="fa fa-file-download" style="width:20px"></span>Download',
css_class=f'btn btn-{message_class} btn-sm w-100',
type='submit',
name='download-samplesheet'),
css_class='col-4'),
css_class='row'),
css_class=f'container alert alert-{message_class}'))
class PositionDetailForm(ModelForm):
required_css_class = 'required'
error_css_class = 'error'
posture = CharField(
widget=Textarea(attrs={'class': 'admin-tiny-mce'}),
required=False,
initial=" ")
contents = CharField(
widget=Textarea(attrs={'class': 'admin-tiny-mce'}),
required=False,
initial=" ")
position = ModelChoiceField(
widget=AddAnotherEditSelectedWidgetWrapper(
autocomplete.ModelSelect2(url='position-autocomplete'),
reverse_lazy('position-add', urlconf='shastra_compedium.urls'),
reverse_lazy('position-update',
urlconf='shastra_compedium.urls',
args=['__fk__'])),
required=False,
queryset=Position.objects.all())
class Meta:
model = PositionDetail
fields = [
'position',
'sources',
'chapter',
'verse_start',
'verse_end',
'usage',
'contents',
]
widgets = {
'chapter': NumberInput(attrs={'style': 'width: 50px'}),
'verse_start': NumberInput(attrs={'style': 'width: 50px'}),
'verse_end': NumberInput(attrs={'style': 'width: 50px'}),
'usage': HiddenInput(),
'sources': MultipleHiddenInput(),
}
class HarvestForm(RecordForm):
recorded = RecordedField(label='Date')
crop = ModelChoiceField(
label="Crop name",
queryset=Crop.objects.filter(needs_moderation=False),
error_messages={
'required': "Please enter a crop name",
},
widget=AddNewCropWidget(),
)
crop_variety = VarietyField(
queryset=Variety.objects.filter(needs_moderation=False),
required=False,
)
def __init__(self, initial={}, *args, **kwargs):
super(HarvestForm, self).__init__(initial=initial, *args, **kwargs)
garden = initial.get('garden', None)
# Only get gardeners of this garden
self.fields['gardener'].queryset = self.get_gardeners(garden)
def get_gardeners(self, garden):
return Gardener.objects.filter(garden=garden).order_by('name')
class Meta:
model = Harvest
exclude = ('added', )
widgets = {
'area': TextInput(attrs={
'size': 5,
'maxlength': 5
}),
'gardener': AddNewGardenerWidget(),
'plants': TextInput(attrs={
'size': 5,
'maxlength': 5
}),
}
def __init__(self, user, instance, *args, **kwargs):
# super(UserRoleDeleteForm, self).__init__(user, *args, **kwargs)
super().__init__(user, *args, **kwargs)
# self.role_to_delete = role_2_del = self.initial['role_to_delete']
self.role_to_delete = instance
# self.using_users = users = CremeUser.objects.filter(role=role_2_del)
self.using_users = users = CremeUser.objects.filter(role=instance)
if users:
self.fields['to_role'] = ModelChoiceField(
label=ugettext('Choose a role to transfer to'),
# queryset=UserRole.objects.exclude(id=role_2_del.id),
queryset=UserRole.objects.exclude(id=instance.id),
)
else:
self.fields['info'] = CharField(
label=ugettext('Information'),
required=False,
widget=Label,
initial=ugettext('This role is not used by any user,'
' you can delete it safely.'),
)
class GroupOfProbesInlineChangeForm(ModelForm):
def __init__(self, *args, **kwargs):
rquser = SharedInfo()
self.user = rquser.getuser()
if self.user.is_authenticated:
self.usergroups = self.user.groupsofprobes.all()
super(GroupOfProbesInlineChangeForm, self).__init__(*args, **kwargs)
qs = GroupOfProbes.objects.all()
groupofprobes = ModelChoiceField(
queryset=qs, help_text='Probe is a member of given group')
groupofprobes.empty_label = '----------------'
groupofprobes.label = 'Group'
def clean_groupofprobes(self):
groupsel = self.cleaned_data['groupofprobes']
gr = SharedInfo(grname=groupsel)
ugid = [f.id for f in self.usergroups]
if groupsel.id not in ugid and not self.user.is_superuser:
raise ValidationError("You are not member of group %s." %
(str(groupsel)))
return groupsel
class HardwareModelForm(forms.ModelForm):
hw_description = forms.CharField(label='Hardware Description', widget=forms.TextInput(), required=True)
hw_vend_fk = ModelChoiceField(label='Vendor', queryset=Vendor.objects.all().order_by('vend_name'), initial=0, required=True)
hw_repl_desc = forms.CharField(label='Replacement Hardware Description', widget=forms.TextInput(), required=False)
hw_repl_vend_fk = ModelChoiceField(label='Replacement Hardware Vendor', queryset=Vendor.objects.all().order_by('vend_name'), initial=0, required=False)
hw_cust_fk = ModelChoiceField(label='Customer', queryset=Customer.objects.all().order_by('cust_name'), initial=0, required=False)
hw_portsts_fk = ModelChoiceField(label='Portfolio Status', queryset=PortfolioStatus.objects.all(), initial=0, required=False)
hw_hwcat_fk = ModelChoiceField(label='Hardware Category', queryset=HardwareCategory.objects.all().order_by('hwcat_name'), initial=0, required=False)
hw_hwsts_fk = ModelChoiceField(label='Hardware Status', queryset=HardwareStatus.objects.all(), initial=0, required=False)
hw_int_code = forms.CharField(label='Internal Part Code', widget=forms.TextInput(), required=False)
hw_ext_code = forms.CharField(label='External Part Code', widget=forms.TextInput(), required=False)
hw_eol_date = forms.DateField(label='End of Life', widget=DatePicker(), required=False) # End of Life
hw_eow_date = forms.DateField(label='End of Warranty', widget=DatePicker(), required=False) # End of Warranty
hw_ems_date = forms.DateField(label='End of Mainstream Support', widget=DatePicker(), required=False) # End of Mainstream Support
hw_ees1_date = forms.DateField(label='End of Extended Support - Period 1', widget=DatePicker(), required=False) # End of Extended Support - Period One
hw_ees2_date = forms.DateField(label='End of Extended Support - Period 2', widget=DatePicker(), required=False) # End of Extended Support - Period Two
hw_ees3_date = forms.DateField(label='End of Extended Support - Period 3', widget=DatePicker(), required=False) # End of Extended Support - Period Three
hw_see_yn_fk = forms.ModelChoiceField(label='Support End Estimated', queryset=YesNo.objects.all().order_by('yesno_id'), initial=2, required=False) # Support End Estimated
hw_plp_txt = forms.CharField(label='Product Lifecycle Policy', widget=forms.TextInput(), required=False) # Product Lifecycle Policy
hw_upd_date = forms.DateField(label='Information Updated', widget=DatePicker(), required=False)
hw_int_reference = forms.CharField(label='Internal Process Reference', widget=forms.TextInput(), required=False)
class Meta:
model = Hardware
fields = [
"hw_description",
"hw_vend_fk",
"hw_repl_desc",
"hw_repl_vend_fk",
"hw_cust_fk",
"hw_portsts_fk",
"hw_hwcat_fk",
"hw_hwsts_fk",
"hw_int_code",
"hw_ext_code",
"hw_eol_date",
"hw_eow_date",
"hw_ems_date",
"hw_ees1_date",
"hw_ees2_date",
"hw_ees3_date",
"hw_see_yn_fk",
"hw_plp_txt",
"hw_upd_date",
"hw_int_reference",
]
class CustomRegistrationForm(RegistrationForm):
username = forms.RegexField(regex=r'^\w+$',
max_length=30,
label=_('Username'),
error_messages={
'invalid':
_('A username must contain letters, '
'numbers, or underscores')
})
display_name = CharField(max_length=50,
required=False,
label=_('Real name (optional)'))
timezone = ChoiceField(label=_('Location'), choices=TIMEZONE)
organizations = SortedMultipleChoiceField(
queryset=Organization.objects.filter(is_open=True),
label=_('Organizations'),
required=False)
language = ModelChoiceField(queryset=Language.objects.all(),
label=_('Preferred language'),
empty_label=None)
if newsletter_id is not None:
newsletter = forms.BooleanField(label=_('Subscribe to newsletter?'),
initial=False)
def clean_email(self):
if User.objects.filter(email=self.cleaned_data['email']).exists():
raise forms.ValidationError(
ugettext(
u'The email address "%s" is already taken. Only one registration '
u'is allowed per address.') % self.cleaned_data['email'])
if '@' in self.cleaned_data['email'] and \
self.cleaned_data['email'].split('@')[-1] in getattr(settings, 'BAD_MAIL_PROVIDERS', set()):
raise forms.ValidationError(
ugettext(
u'Your email provider is not allowed due to history of abuse. '
u'Please use a reputable email provider.'))
return self.cleaned_data['email']
class ObjectivesFromPatternForm(CremeForm):
pattern = ModelChoiceField(label=_('Pattern'),
empty_label=None,
queryset=ActObjectivePattern.objects.all())
def __init__(self, entity, *args, **kwargs):
# super(ObjectivesFromPatternForm, self).__init__(*args, **kwargs)
super().__init__(*args, **kwargs)
self.act = entity
self.fields['pattern'].queryset = ActObjectivePattern.objects.filter(
segment=entity.segment_id)
def save(self, *args, **kwargs):
act = self.act
pattern = self.cleaned_data['pattern']
create_objective = ActObjective.objects.create
won_opps = int(
ceil(float(act.expected_sales) / float(pattern.average_sales)))
create_objective(act=act,
name=ugettext('Number of won opportunities'),
counter_goal=won_opps)
def create_objectives_from_components(comps, parent_goal):
for comp in comps:
counter_goal = int(
ceil(parent_goal * (100.0 / comp.success_rate)))
create_objective(act=act,
name=comp.name,
counter_goal=counter_goal,
ctype_id=comp.ctype_id,
filter_id=comp.filter_id)
create_objectives_from_components(comp.get_children(),
counter_goal)
create_objectives_from_components(pattern.get_components_tree(),
won_opps)
class ExtractionForm(ModelForm):
extractions = ModelChoiceField(queryset=Extraction.objects.all().filter(factured=False), help_text='Select the Extraction you want to set as factured',
label='Extractions list:')
class Meta:
model = Extraction
error_css_class = 'error'
required_css_class = 'required'
fields = ('extractions',)
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.help_text_inline = False
self.helper.form_class = 'form-horizontal mr-1'
self.helper.form_id = 'form_id'
self.helper.form_tag = False
self.helper.layout = Layout(
Row(
Column('extractions', css_class='form-group col-md-6 mb-0 mr-1'),
Submit('submit', 'Set as Factured', css_class='ml-1'),
css_class='form-row mr-1'
),
Div(css_class='mb-2')
)
super().__init__(*args, **kwargs)
for field in self.fields:
help_text = self.fields[field].help_text
self.fields[field].help_text = None
if help_text != '':
self.fields[field].widget.attrs.update(
{'class': 'has-popover',
'data - toggle': 'popover',
'data-content': help_text, 'data-placement': 'right',
'data-container': 'body'})
self.fields['extractions'].widget.attrs.update({'class': 'extfield'})
