class RestrictionsForm(forms.ModelForm):
start_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("Start date"),
required=False)
end_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("End date"),
required=False)
def __init__(self, *args, **kwargs):
super(RestrictionsForm, self).__init__(*args, **kwargs)
today = datetime.date.today()
self.fields['start_datetime'].initial = today.strftime(
self.fields['start_datetime'].widget.format)
class Meta:
model = ConditionalOffer
fields = ('start_datetime', 'end_datetime', 'max_basket_applications',
'max_user_applications', 'max_global_applications',
'max_discount')
def clean(self):
cleaned_data = super(RestrictionsForm, self).clean()
start = cleaned_data['start_datetime']
end = cleaned_data['end_datetime']
if start and end and end < start:
raise forms.ValidationError(
_("The end date must be after the start date"))
return cleaned_data
class RestrictionsForm(forms.ModelForm):
start_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("Start date"),
required=False)
end_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("End date"),
required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
today = datetime.date.today()
self.fields['start_datetime'].initial = today
class Meta:
model = ConditionalOffer
fields = ('start_datetime', 'end_datetime', 'max_basket_applications',
'max_user_applications', 'max_global_applications',
'max_discount', 'priority', 'exclusive', 'combinations')
def clean(self):
cleaned_data = super().clean()
start = cleaned_data['start_datetime']
end = cleaned_data['end_datetime']
if start and end and end < start:
raise forms.ValidationError(
_("The end date must be after the start date"))
exclusive = cleaned_data['exclusive']
combinations = cleaned_data['combinations']
if exclusive and combinations:
raise forms.ValidationError(
_('Exclusive offers cannot be combined'))
return cleaned_data
def save(self, *args, **kwargs):
"""Store the offer combinations.
Also, and make sure the combinations are stored on the combine-able
offers as well.
"""
instance = super().save(*args, **kwargs)
if instance.id:
instance.combinations.clear()
for offer in self.cleaned_data['combinations']:
if offer != instance:
instance.combinations.add(offer)
combined_offers = instance.combined_offers
for offer in combined_offers:
if offer == instance:
continue
for otheroffer in combined_offers:
if offer == otheroffer:
continue
offer.combinations.add(otheroffer)
return instance
class Meta:
model = Voucher
fields = [
'name',
'code',
'start_datetime',
'end_datetime',
'usage',
]
widgets = {
'start_datetime': widgets.DateTimePickerInput(),
'end_datetime': widgets.DateTimePickerInput(),
}
class Meta:
model = VoucherSet
fields = [
'name',
'code_length',
'description',
'start_datetime',
'end_datetime',
'count',
]
widgets = {
'start_datetime': widgets.DateTimePickerInput(),
'end_datetime': widgets.DateTimePickerInput(),
}
class PostForm(forms.ModelForm):
post_body = forms.CharField(required=False,
label=_('Body'),
widget=widgets.WYSIWYGTextArea())
created = forms.DateTimeField(required=False,
label=_('Date Published'),
widget=widgets.DateTimePickerInput())
class Meta:
model = PostEntry
fields = ('title', 'author', 'created', 'category', 'post_body',
'image', 'published')
def clean_name(self):
if not self.instance.id:
if PostEntry.objects.filter(
slug=slugify(self.cleaned_data['title'])).exists():
raise forms.ValidationError(
'Blog with this title already exists.')
else:
if PostEntry.objects.filter(
title=self.cleaned_data['title']).exclude(
id=self.instance.id):
raise forms.ValidationError(
'Blog with this title already exists.')
return self.cleaned_data['category']
def test_div_attrs_context(self):
i = widgets.DateTimePickerInput(format='%d/%m/%Y %H:%M')
ctx = i.get_context('test_input', None, {})
self.assertEqual(ctx['div_attrs'], {
'data-oscarWidget': 'datetime',
'data-datetimeFormat': 'DD/MM/YYYY HH:mm',
})
class CareerForm(forms.ModelForm):
body = forms.CharField(required=False,
label=_('Body'),
widget=widgets.WYSIWYGTextArea())
date_published = forms.DateTimeField(required=False,
label=_('Date Published'),
widget=widgets.DateTimePickerInput())
class Meta:
model = Career
fields = ('title', 'date_published', 'departement', 'body',
'published')
def clean_title(self):
if not self.instance.id:
if Career.objects.filter(
slug=slugify(self.cleaned_data['title'])).exists():
raise forms.ValidationError(
'Career with this title already exists.')
else:
if Career.objects.filter(title=self.cleaned_data['title']).exclude(
id=self.instance.id):
raise forms.ValidationError(
'Career with this title already exists.')
return self.cleaned_data['title']
class FlashSaleForm(forms.Form):
TYPE_CHOICES = (
(Benefit.PERCENTAGE,
_("Discount is a percentage off of the product's value")),
(Benefit.FIXED_PRICE,
_("Get the products that meet the condition for a fixed price")),
(Benefit.FIXED_PER_PRODUCT,
_("Discount is a fixed amount off of each product's value that match condition"
)),
)
start_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("Start date"),
required=False)
end_datetime = forms.DateTimeField(widget=widgets.DateTimePickerInput(),
label=_("End date"),
required=False)
benefit_type = forms.ChoiceField(choices=TYPE_CHOICES)
benefit_value = forms.DecimalField()
class VoucherForm(forms.Form):
"""
A specialised form for creating a voucher and offer
model.
"""
name = forms.CharField(label=_("Name"))
code = forms.CharField(label=_("Code"))
start_datetime = forms.DateTimeField(
widget=widgets.DateTimePickerInput(),
label=_("Start datetime"))
end_datetime = forms.DateTimeField(
widget=widgets.DateTimePickerInput(),
label=_("End datetime"))
usage = forms.ChoiceField(choices=Voucher.USAGE_CHOICES, label=_("Usage"))
benefit_range = forms.ModelChoiceField(
label=_('Which products get a discount?'),
queryset=Range.objects.all(),
)
type_choices = (
(Benefit.PERCENTAGE, _('Percentage off of products in range')),
(Benefit.FIXED, _('Fixed amount off of products in range')),
(Benefit.SHIPPING_PERCENTAGE,
_("Discount is a percentage off of the shipping cost")),
(Benefit.SHIPPING_ABSOLUTE,
_("Discount is a fixed amount of the shipping cost")),
(Benefit.SHIPPING_FIXED_PRICE, _("Get shipping for a fixed price")),
)
benefit_type = forms.ChoiceField(
choices=type_choices,
label=_('Discount type'),
)
benefit_value = forms.DecimalField(
label=_('Discount value'))
exclusive = forms.BooleanField(
required=False,
label=_("Exclusive offers cannot be combined on the same items"))
def __init__(self, voucher=None, *args, **kwargs):
self.voucher = voucher
super().__init__(*args, **kwargs)
def clean_name(self):
name = self.cleaned_data['name']
try:
voucher = Voucher.objects.get(name=name)
except Voucher.DoesNotExist:
pass
else:
if (not self.voucher) or (voucher.id != self.voucher.id):
raise forms.ValidationError(_("The name '%s' is already in"
" use") % name)
return name
def clean_code(self):
code = self.cleaned_data['code'].strip().upper()
if not code:
raise forms.ValidationError(_("Please enter a voucher code"))
try:
voucher = Voucher.objects.get(code=code)
except Voucher.DoesNotExist:
pass
else:
if (not self.voucher) or (voucher.id != self.voucher.id):
raise forms.ValidationError(_("The code '%s' is already in"
" use") % code)
return code
def clean(self):
cleaned_data = super().clean()
start_datetime = cleaned_data.get('start_datetime')
end_datetime = cleaned_data.get('end_datetime')
if start_datetime and end_datetime and end_datetime < start_datetime:
raise forms.ValidationError(_("The start date must be before the"
" end date"))
return cleaned_data
def test_datetimepickerinput_format_unicode(self):
# Check that the widget can handle unicode formats
i = widgets.DateTimePickerInput(format='δ-%d/%m/%Y %H:%M')
date = datetime.datetime(2017, 5, 1, 10, 57)
html = i.render('datetime', date)
self.assertIn('value="δ-01/05/2017 10:57"', html)
def test_icon_classes_context(self):
i = widgets.DateTimePickerInput(format='%d/%m/%Y %H:%M')
ctx = i.get_context('test_input', None, {})
self.assertEqual(ctx['icon_classes'], 'far fa-calendar-alt')
class ConfirmationPostForm(forms.ModelForm):
destination_bank = forms.ChoiceField(label=_('Destination Bank'),
choices=())
transfer_date = forms.DateTimeField(required=False,
label=_('Transfer Date'),
widget=widgets.DateTimePickerInput())
note = forms.CharField(label=_('Note'),
widget=forms.Textarea,
required=False)
def __init__(self, bank_account=None, *args, **kwargs):
super(ConfirmationPostForm, self).__init__(*args, **kwargs)
self.fields['destination_bank'].choices = self.initial_bank_choices()
self.fields['proof_payment'].required = True
self.fields['note'].widget.attrs['rows'] = 3
for field in ['order_number', 'amount']:
self.fields[field].widget.attrs['readonly'] = True
def initial_bank_choices(self):
bank_choices = []
for bank in settings.BANK_ACCOUNT_LIST:
bank_choices.append((bank['label'], bank['label']), )
return bank_choices
def send_email(self, site, recipient, number):
code = 'CONFIRMATION'
ctx = {'order_number': number, 'site': site}
try:
event_type = CommunicationEventType.objects.get(code=code)
except CommunicationEventType.DoesNotExist:
messages = CommunicationEventType.objects.get_and_render(code, ctx)
else:
messages = event_type.get_messages(ctx)
if messages and messages['body']:
Dispatcher().dispatch_direct_messages(recipient, messages)
def send_email_to_cs(self, site, sender, number):
ctx = {'number': number, 'site': site, 'sender': sender}
try:
event_type = CommunicationEventType.objects.get(
code='GET_NEW_CONFIRMATION')
except CommunicationEventType.DoesNotExist:
messages = CommunicationEventType.objects.get_and_render(
'GET_NEW_CONFIRMATION', ctx)
else:
messages = event_type.get_messages(ctx)
if messages and messages['body']:
Dispatcher().send_random_email_messages(messages, sender)
def clean_order_number(self):
order_number = self.cleaned_data.get("order_number")
if not Order.objects.exclude(pk=self.instance.pk).filter(
number=order_number).exists():
raise forms.ValidationError(
_('Order number "%(order_number)s" is not found'),
params={'order_number': order_number},
)
if ConfirmationPayment.objects.filter(order_number=order_number,
status='accept').exists():
raise forms.ValidationError(
_('Confirmation with order number "%(order_number)s" has been accepted'
),
params={'order_number': order_number},
)
return order_number
def clean_proof_payment(self):
proof_payment = self.cleaned_data['proof_payment']
if proof_payment._size > settings.MAX_UPLOAD_SIZE:
raise forms.ValidationError(
_('Please keep filesize under "%(max_size)s". Current filesize "%(current_size)s"'
),
params={
'max_size': filesizeformat(settings.MAX_UPLOAD_SIZE),
'current_size': filesizeformat(proof_payment._size)
},
)
return proof_payment
class Meta:
model = ConfirmationPayment
fields = [
'account_owner_name', 'transfer_date', 'destination_bank',
'amount', 'order_number', 'customer_email', 'customer_phone',
'note', 'proof_payment'
]
class Meta:
model = Appointment
exclude = ('date_created',)
datetime = forms.DateField(input_formats='%d/%m/%Y',
label=_("End datetime"), widget=widgets.DateTimePickerInput())
class VoucherForm(forms.Form):
name = forms.CharField(label=_("Name"), max_length=128)
description = forms.CharField(label=_("Description"),
widget=forms.Textarea,
required=False)
code = forms.CharField(label=_("Code"))
create_children = forms.BooleanField(
label=_('Should child codes be created?'), required=False)
child_count = forms.IntegerField(
label=_('How many child codes should be created?'),
initial=0,
min_value=0,
max_value=MAX_CHILDREN_CREATE,
required=False)
start_datetime = forms.DateTimeField(label=_("Start datetime"),
widget=widgets.DateTimePickerInput())
end_datetime = forms.DateTimeField(label=_("End datetime"),
widget=widgets.DateTimePickerInput())
priority = forms.IntegerField(
label=_("Priority"),
initial=0,
min_value=0,
help_text=_("The highest priority vouchers are applied first"))
usage = forms.ChoiceField(label=_("Usage"), choices=Voucher.USAGE_CHOICES)
limit_usage_by_group = forms.BooleanField(
label=_('Should usage be limited to specific user groups?'),
required=False)
groups = forms.ModelMultipleChoiceField(
label=_('User Group Whitelist'),
help_text=_("Which user groups will be able to apply this offer?"),
queryset=Group.objects.order_by('name'),
required=False)
condition = forms.ModelChoiceField(
label=_('Condition'),
help_text=
_("In addition to entering the voucher code, what precondition (if any) must be met before this voucher is applied?"
),
queryset=Condition.objects.get_queryset(),
required=False)
desktop_image = forms.ImageField(
label=_('Desktop Image'),
help_text=_("Desktop image used for promo display."),
required=False)
mobile_image = forms.ImageField(
label=_('Mobile Image'),
help_text=_("Mobile image used for promo display."),
required=False)
benefit = forms.ModelChoiceField(
label=_('Incentive'),
help_text=
_("What benefit should be given to the customer as a result of this voucher code?"
),
queryset=Benefit.objects.get_queryset())
offer_group = forms.ModelChoiceField(
label=_('Offer Group'),
help_text=_("What group should this voucher belong to?"),
queryset=OfferGroup.objects.get_queryset())
max_global_applications = forms.IntegerField(
label=_("Max global applications"),
min_value=0,
required=False,
help_text=
_("The number of times this offer can be used before it is unavailable"
))
max_user_applications = forms.IntegerField(
label=_("Max user applications"),
min_value=0,
required=False,
help_text=_("The number of times a single user can use this offer"))
max_basket_applications = forms.IntegerField(
label=_("Max basket applications"),
min_value=0,
required=False,
help_text=
_("The number of times this offer can be applied to a basket (and order)"
))
max_discount = forms.DecimalField(
label=_("Max discount"),
min_value=0,
decimal_places=2,
max_digits=12,
required=False,
help_text=
_("When an offer has given more discount to orders than this threshold, then the offer becomes unavailable"
))
def __init__(self, voucher=None, *args, **kwargs):
self.voucher = voucher
super().__init__(*args, **kwargs)
def clean_name(self):
name = self.cleaned_data['name'].strip()
if not name:
raise forms.ValidationError(_("Please enter a voucher name"))
qs = Voucher.objects
if self.voucher:
qs = qs.exclude(pk=self.voucher.pk)
qs = qs.filter(parent=None)
qs = qs.filter(name=name)
if qs.count() > 0:
raise forms.ValidationError(
_("The name '%s' is already in use") % name)
return name
def clean_code(self):
code = self.cleaned_data['code'].strip().upper()
if not code:
raise forms.ValidationError(_("Please enter a voucher code"))
qs = Voucher.objects
if self.voucher:
qs = qs.exclude(pk=self.voucher.pk)
qs = qs.filter(code=code)
if qs.count() > 0:
raise forms.ValidationError(
_("The code '%s' is already in use") % code)
return code
def clean(self):
cleaned_data = super().clean()
start_datetime = cleaned_data.get('start_datetime')
end_datetime = cleaned_data.get('end_datetime')
if start_datetime and end_datetime and end_datetime < start_datetime:
raise forms.ValidationError(
_("The start date must be before the end date"))
return cleaned_data
