class PartialStationForm(ModelForm):
beacon = CharField()
lat = FloatField()
lng = FloatField()
main_img_num = IntegerField(required=False)
def __init__(self, *args, **kwargs):
super(PartialStationForm, self).__init__(*args, **kwargs)
for i in range(1, settings.MAX_IMGS_UPLOAD + 1):
field_name = 'img{0}'.format(i)
self.fields[field_name] = ImageField(required=False)
class Meta:
model = Station
exclude = ['location']
def get_variation_selection_form(request, product): # pragma: no cover
# TODO: Does this belong here? Eliding from coverage meanwhile.
variables = ProductVariationVariable.objects.filter(
product=product).order_by("name").values_list("id", "name")
values = defaultdict(list)
for var_id, val_id, val in (ProductVariationVariableValue.objects.filter(
variable__product=product).values_list("variable_id", "id",
"value")):
values[var_id].append((val_id, val))
form = Form(data=request.POST if request.POST else None)
for variable_id, variable_name in variables:
var_values = sorted(values.get(variable_id, ()))
form.fields["var_%d" % variable_id] = IntegerField(
label=variable_name, widget=Select(choices=var_values))
return form
class OfferForm(ModelForm):
price = IntegerField(
label='Precio',
error_messages=default_error_messages,
)
end_date = DateField(
label='Fecha de fin',
error_messages=default_error_messages,
widget=SelectDateWidget,
)
class Meta:
model = Offer
fields = ['price', 'end_date']
class ReservationAbuseForm(Form):
cancellation_horizon = IntegerField(initial=6, min_value=1)
cancellation_penalty = IntegerField(initial=10)
target = CharField(required=False)
start = DateField(initial=timezone.now().replace(day=1).date())
end = DateField(initial=timezone.now().date())
def clean_cancellation_horizon(self):
# Convert the cancellation horizon from hours to seconds.
return self.cleaned_data['cancellation_horizon'] * 60 * 60
def clean_start(self):
start = self.cleaned_data['start']
return timezone.make_aware(
datetime(year=start.year,
month=start.month,
day=start.day,
hour=0,
minute=0,
second=0,
microsecond=0), timezone.get_current_timezone())
def clean_end(self):
end = self.cleaned_data['end']
return timezone.make_aware(
datetime(year=end.year,
month=end.month,
day=end.day,
hour=23,
minute=59,
second=59,
microsecond=999999), timezone.get_current_timezone())
def get_target(self):
target = self.cleaned_data['target'].split('|', 1)
return ReservationItemType(target[0]), int(target[1])
class ManualCleanupForm(Form):
limit_days = IntegerField(min_value=1,
required=False,
label='Maximum age (days)',
help_text=' - remove objects older than X days')
limit_size = IntegerField(
min_value=1,
required=False,
label='Purge used space (Gb)',
help_text=" - remove old objects until total size won't reach X GB")
def cleanup(self):
model = self.initial['type'].split('__')
task_kwargs = self.get_task_kwargs()
signature("tasks.deferred_manual_cleanup",
args=(model, ),
kwargs=task_kwargs).apply_async(queue='limitation')
def get_task_kwargs(self):
task_kwargs = dict(
limit_size=self.cleaned_data['limit_size'],
limit_days=self.cleaned_data['limit_days'],
)
return task_kwargs
def _collect_type_fields(self):
containers = []
for product in SubscriptionProductDao.get_all_visible().order_by('pk'):
product_container = CategoryContainer(instance=product)
for subscription_size in product.sizes.filter(visible=True).order_by('pk'):
size_container = CategoryContainer(instance=subscription_size, name=subscription_size.long_name)
for subscription_type in subscription_size.types.filter(visible=True).order_by('pk'):
field_name = f'amount[{subscription_type.id}]'
self.fields[field_name] = IntegerField(label=subscription_type.name, min_value=0,
initial=self._get_initial(subscription_type))
size_container.append(SubscriptionTypeField(field_name, instance=subscription_type))
product_container.append(size_container)
containers.append(product_container)
return containers
class NumberSelectField(BaseResponseForm):
answer = IntegerField()
def __init__(self, *args, **kwargs):
super(NumberSelectField, self).__init__(*args, **kwargs)
self.min_value = int(self.question.get_attribute('min_value', 0))
self.max_value = int(self.question.get_attribute('max_value', 45))
self.choices = tuple([
(x, x) for x in range(self.min_value, self.max_value + 1)
])
self.fields['answer'].widget = Select(choices=self.choices,
attrs={
'min': self.min_value,
'max': self.max_value
})
class SQLHelperTextAnywhereForm(forms.Form):
fkname = CharField(label="Field name containing patient research ID",
required=True)
min_length = IntegerField(
label="Minimum length of textual field (suggest e.g. 50)",
min_value=1,
required=True)
fragment = CharField(label="String fragment to find", required=True)
use_fulltext_index = BooleanField(
label="Use full-text indexing where available "
"(faster, but requires whole words)",
required=False)
include_content = BooleanField(
label="Include content from fields where found (slower)",
required=False)
class AddCoMemberForm(CoMemberBaseForm):
shares = IntegerField(label=Config.vocabulary('share_pl'), required=False, min_value=0, initial=0)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
fields = list(self.base_layout) # keep first 9 fields
if Config.enable_shares():
fields.append(Field('shares', css_class='col-md-2'))
self.helper.layout = Layout(
*fields,
FormActions(
self.get_submit_button(),
LinkButton(_("Abbrechen"), reverse("sub-detail")),
)
)
def get_thread_shared_users(request):
"""returns snippet of html with users"""
thread_id = request.GET['thread_id']
thread_id = IntegerField().clean(thread_id)
thread = models.Thread.objects.get(id=thread_id)
users = thread.get_users_shared_with()
data = {
'users': users,
}
html = render_into_skin_as_string('widgets/user_list.jinja', data, request)
return JsonResponse({
'html': html,
'users_count': users.count(),
'success': True
})
class ExtendedApprovalSettingsForm(SettingsForm):
grace_period_diffset = IntegerField(
label='Grace period (Diffset) in seconds',
help_text='Time to "last diffset" review request being approved.')
grace_period_shipit = IntegerField(
label='Grace period (Ship It!) in seconds',
help_text='Time to "Ship It" review request being approved.')
enable_revoke_shipits = BooleanField(
required=False,
label='Revoke previous ShipIts',
help_text='Revoke all ShipIts after a new diff was uploaded.')
enable_target_shipits = BooleanField(
required=False,
label='Allow ShipIts of target groups/people only',
help_text=('Do not accept ShipIts if the user is not in '
'review group/people.'))
forbidden_user_shipits = CharField(
required=False,
label='User who can never ShipIt',
help_text='Comma separated list of usernames.')
class ThreadListGetForm(Form):
"""
A form to validate query parameters in the thread list retrieval endpoint
"""
course_id = CharField()
page = IntegerField(required=False, min_value=1)
page_size = IntegerField(required=False, min_value=1)
def clean_course_id(self):
"""Validate course_id"""
value = self.cleaned_data["course_id"]
try:
return CourseLocator.from_string(value)
except InvalidKeyError:
raise ValidationError(
"'{}' is not a valid course id".format(value))
def clean_page(self):
"""Return given valid page or default of 1"""
return self.cleaned_data.get("page") or 1
def clean_page_size(self):
"""Return given valid page_size (capped at 100) or default of 10"""
return min(self.cleaned_data.get("page_size") or 10, 100)
class YumYuckForm(RecordForm):
recorded = RecordedField(label='Event date')
crop = ModelChoiceField(
label='Crop name',
queryset=Crop.objects.filter(needs_moderation=False),
widget=AddNewCropWidget(),
)
yum_before = IntegerField(label='Yums')
yuck_before = IntegerField(label='Yucks')
yum_after = IntegerField(label='Yums')
yuck_after = IntegerField(label='Yucks')
class Meta:
model = YumYuck
fields = (
'recorded',
'crop',
'yum_before',
'yuck_before',
'yum_after',
'yuck_after',
'added_by',
'garden',
)
class AppInfo(models.Model):
id = IntegerField(label='ID')
version_name = models.CharField(max_length=50)
version_code = models.IntegerField()
version_type = models.IntegerField(default=0)
update_info = models.TextField()
app_file = models.FileField(upload_to='apk/%Y-%m-%d %H:%M:%S/')
datetime = models.DateTimeField(auto_now=True, blank=True, null=True)
def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
super(AppInfo, self).save(force_insert, force_update, using, update_fields)
upload_file(self.app_file.file.name, 'APKs/' + os.path.basename(self.app_file.name))
def __str__(self):
return self.version_name + '(' + str(self.version_code) + ')'
class CreateBridgeForm(Form):
context = CharField(
max_length=20,
required=False,
label='Kontekst',
widget=TextInput(attrs={
'value': 'polaczenia',
'readonly': 'true',
'class': 'form-control'
}))
exten = CharField(max_length=20,
required=True,
label='ID mostku',
widget=TextInput(attrs={'class': 'form-control'}))
priority = IntegerField(
required=False,
label='Prioritet',
widget=NumberInput(attrs={
'value': 1,
'readonly': 'true',
'class': 'form-control'
}))
app = CharField(
max_length=20,
required=True,
label='Aplikacja',
widget=TextInput(attrs={
'value': 'ConfBridge',
'readonly': 'true',
'class': 'form-control'
}))
appdata = CharField(max_length=20,
required=False,
label='Nazwa mostku (czytelna)',
widget=TextInput(attrs={'class': 'form-control'}))
def __init__(self, *args, **kwargs):
super(CreateBridgeForm, self).__init__(*args, **kwargs)
def save_bridge(self, form_data):
bridge = BridgeModel()
for key in form_data:
if hasattr(bridge, key):
setattr(bridge, key, form_data.get(key))
bridge.save()
print('Bridge with id {bridge_id} created'.format(
bridge_id=form_data.get('appdata')))
return bridge
class MapUpdateFilterForm(Form):
type = ChoiceField(choices=(('', _('any type')), ) + MapUpdate.TYPES,
required=False)
geometries_changed = ChoiceField(choices=(('', _('any')),
('1', _('geometries changed')),
('0',
_('no geometries changed'))),
required=False)
processed = ChoiceField(choices=(('', _('any')), ('1', _('processed')),
('0', _('not processed'))),
required=False)
user_id = IntegerField(min_value=1, required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['user_id'].widget.attrs['placeholder'] = _('user id')
class CuratorSearchForm(Form):
fullSearch = CharField(max_length=255, required=False)
useMUIS = BooleanField(initial=False, required=False)
useDIGAR = BooleanField(initial=False, required=False)
useMKA = BooleanField(initial=False, required=False)
useETERA = BooleanField(initial=False, required=False)
useFlickr = BooleanField(initial=False, required=False)
useUTLIB = BooleanField(initial=False, required=False)
useFinna = BooleanField(initial=False, required=False)
useCommons = BooleanField(initial=False, required=False)
useEuropeana = BooleanField(initial=False, required=False)
useFotis = BooleanField(initial=False, required=False)
# Also used for Finna and Fotis
flickrPage = IntegerField(initial=1, required=False)
filterExisting = BooleanField(initial=True, required=False)
ids = NotValidatedMultipleChoiceField(coerce=str, required=False)
class ProductForm(forms.Form):
product_type = ModelChoiceField(queryset=ProductType.objects.select_related().all().order_by('name'),
widget=Select(), label='Product Type')
product_name = CharField(label='Product Name', required=True)
price = DecimalField(label='Price', min_value=0)
description = CharField(label='Description')
storage = IntegerField(label='Storage', min_value=0)
product_code = CharField(label='Product Code')
def save(self):
data = self.cleaned_data
product = AllProduct(product_type=ProductType.object.get(name=data['product_type']['name']),
prodect_name=data['product_name'], price=data['price'],
description=data['description'], storage=data['storage'],
product_code=data['product_code'])
product.save()
def test_integerfield_5(self):
f = IntegerField(min_value=10, max_value=20)
self.assertWidgetRendersTo(f, '<input id="id_f" max="20" type="number" name="f" min="10" required>')
with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
f.clean(None)
with self.assertRaisesMessage(ValidationError, "'Ensure this value is greater than or equal to 10.'"):
f.clean(1)
self.assertEqual(10, f.clean(10))
self.assertEqual(11, f.clean(11))
self.assertEqual(10, f.clean('10'))
self.assertEqual(11, f.clean('11'))
self.assertEqual(20, f.clean(20))
with self.assertRaisesMessage(ValidationError, "'Ensure this value is less than or equal to 20.'"):
f.clean(21)
self.assertEqual(f.max_value, 20)
self.assertEqual(f.min_value, 10)
class AdminEditExchangeInfo(ModelForm):
title = CharField(required=True)
description = CharField(required=True)
spending_max = IntegerField(required=True)
exchange = CharField(widget=HiddenInput(), required=False)
schedule_day = DateField(required=True)
class Meta:
model = GiftExchange
fields = [
'title',
'description',
'spending_max',
'schedule_day',
'exchange'
]
def post(self, request):
parent_id = IntegerField().clean(request.POST['parent_id'])
parent = Message.objects.get(id=parent_id)
message = Message.objects.create_response(sender=request.user,
text=request.POST['text'],
parent=parent)
last_visit = LastVisitTime.objects.get(message=message.root,
user=request.user)
last_visit.at = datetime.datetime.now()
last_visit.save()
return self.render_to_response(
{
'post': message,
'user': request.user
},
template_name='group_messaging/stored_message.html')
class RehearsalSelectionForm(Form):
show = CharField(widget=TextInput(attrs={'readonly': 'readonly'}))
show_private = IntegerField(widget=HiddenInput)
def __init__(self, *args, **kwargs):
super(RehearsalSelectionForm, self).__init__(*args, **kwargs)
if 'rehearsal' in kwargs['initial']:
self.fields['rehearsal'] = ChoiceField(
choices=kwargs['initial']['rehearsal_choices'],
initial=kwargs['initial']['rehearsal'])
else:
self.fields['rehearsal'] = ChoiceField(
choices=kwargs['initial']['rehearsal_choices'])
class Meta:
fields = ['show_private', 'show', 'rehearsal']
class AddChildForm(Form):
nickname = CharField()
shifts_per_month = IntegerField()
parent_email_1 = EmailField(required=False)
parent_email_2 = EmailField(required=False)
def cleaned_emails(self):
return [
self.cleaned_data[email_field]
for email_field in ['parent_email_1', 'parent_email_2']
if self.cleaned_data[email_field]
]
def clean_email(self):
check_unique(self, 'nickname', Child)
def clean(self, value):
if not value and not self.required:
return None
try:
gid = from_global_id(value)
except (TypeError, ValueError, UnicodeDecodeError, binascii.Error):
raise ValidationError(self.error_messages['invalid'])
try:
IntegerField().clean(gid.id)
CharField().clean(gid.type)
except ValidationError:
raise ValidationError(self.error_messages['invalid'])
return value
class EditCoMemberForm(CoMemberBaseForm):
edit = IntegerField(widget=HiddenInput)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# do not edit existing co-members
if self.instance.pk:
for field in self.fields.values():
field.disabled = True
self.helper.layout = Layout(
*self.base_layout, # keep first 9 fields
'edit',
FormActions(Submit('submit', _('Ändern'), css_class='btn-success'),
LinkButton(_('Abbrechen'), '?')))
class AddressForm(Form):
country = CharField(max_length=20, required=False)
city = CharField(max_length=20, required=False)
street = CharField(max_length=20, required=False)
house_no = IntegerField(required=False, min_value=1)
def clean(self):
country = self.cleaned_data['country']
city = self.cleaned_data['city']
street = self.cleaned_data['street']
house_no = self.cleaned_data['house_no']
fields = [country, city, street, house_no]
if any(fields) and any(field is None for field in fields):
self.add_error(
'country',
'Please make sure all the address fields are filled.')
class AlgorithmImageUpdateForm(SaveFormInitMixin, ModelForm):
requires_memory_gb = IntegerField(
min_value=1,
max_value=30,
help_text=
"The maximum system memory required by the algorithm in gigabytes.",
)
class Meta:
model = AlgorithmImage
fields = ("requires_gpu", "requires_memory_gb")
labels = {"requires_gpu": "GPU Supported"}
help_texts = {
"requires_gpu":
"If true, inference jobs for this container will be assigned a GPU"
}
class ScriptThanksExceptForm(ModelForm):
script_id = IntegerField()
class Meta:
model = InterestedPerson
fields = ['email', 'contactme', 'script_id']
widgets = {
'script_id': HiddenInput(),
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['email'].label = "E-mail:"
self.fields[
'contactme'].label = "Check this box if you agree to be invited to participate in other research related to technologies applied to promote healthy ageing."
self.helper = FormHelper()
self.helper.form_id = 'id-scriptthanksexceptform'
self.helper.form_class = 'blueForms'
self.helper.form_method = 'post'
self.helper.form_action = 'finish'
self.helper.layout = Layout(
Field('script_id', type="hidden"),
Row(Column('email', css_class='form-group col-md-8 mb-3 disabled'),
css_class='form-row'),
Row(Column('contactme', css_class='form-group col-md-12 mb-3'),
css_class='form-row'),
Row(Submit('submit', 'Complete', css_class='mb-4 mt-3 btn-lg'),
css_class='form-row thanks-submit'),
)
def set_language(self, replica):
if replica.language == Replica.LANG_POR:
self.fields[
'contactme'].label = "Marque a caixa ao lado caso aceite ser convidado para participar de outras pesquisas relacionadas à aplicação de tecnologia na promoção do envelhecimento saudável."
self.helper.layout = Layout(
Field('script_id', type="hidden"),
Row(Column('email',
css_class='form-group col-md-8 mb-3 disabled'),
css_class='form-row'),
Row(Column('contactme', css_class='form-group col-md-12 mb-3'),
css_class='form-row'),
Row(Submit('submit', 'Concluir', css_class='mb-4 mt-3 btn-lg'),
css_class='form-row thanks-submit'),
)
class RestaurantForm(ModelForm):
opening_time = TimeField(widget=TimeInput(attrs={'type': 'time'}))
closing_time = TimeField(widget=TimeInput(attrs={'type': 'time'}))
name = CharField()
address = CharField()
phone = CharField()
capacity = IntegerField()
image = URLField()
description = Textarea()
category = ModelChoiceField(queryset=Category.objects.all())
class Meta:
model = Restaurant
fields = [
'name', 'description', 'address', 'phone', 'capacity',
'opening_time', 'closing_time', 'image', 'category'
]
def remove(_request, link_id):
""" Remove a specific link with ID ``link_id`` """
field = IntegerField(min_value=1)
try:
value = field.clean(link_id)
except ValidationError as err:
json_data = {'rc': 1, 'response': '\n'.join(err.messages)}
return http.JsonResponse(json_data, status=HTTPStatus.BAD_REQUEST)
# this will silently ignore non-existing objects
LinkReference.objects.filter(pk=value).delete()
return http.JsonResponse({
'rc': 0,
'response': 'Link has been removed successfully.'
})
