class DataForm(forms.Form):
start = forms.DateTimeField(required=True, initial=datetime.now())
end = forms.DateTimeField(required=True)
sensor = forms.ModelChoiceField(queryset=Sensor.objects.all())
class TicketForm(forms.Form):
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.form_id = 'id-ticket_edit_form'
self.helper.form_class = 'well form-horizontal ajax form-condensed'
self.helper.form_method = 'post'
self.helper.form_tag = False
super(TicketForm, self).__init__(*args, **kwargs)
queue = forms.ModelChoiceField(label=_('Queue'),
required=True,
queryset=Queue.objects.all())
title = forms.CharField(
max_length=100,
required=True,
widget=forms.TextInput(),
label=_('Summary of the problem'),
)
owner = forms.ModelChoiceField(
queryset=User.objects.all(),
required=False,
label=_(u'Создал'),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'))
account = forms.ModelChoiceField(queryset=Account.objects.all(),
required=False,
label=_(u'Аккаунт'),
widget=autocomplete_light.ChoiceWidget(
'AccountAutocomplete',
attrs={'class': 'span6 input'}))
assigned_to = forms.ModelChoiceField(
required=False,
queryset=SystemUser.objects.all(),
widget=autocomplete_light.ChoiceWidget('SystemUserAutocomplete'),
label=_(u'Исполнитель'),
)
due_date = forms.DateTimeField(
label=_(u'Due Date'),
required=False,
widget=forms.widgets.DateTimeInput(attrs={'class': 'datepicker'}))
priority = forms.ChoiceField(
choices=Ticket.PRIORITY_CHOICES,
required=False,
initial='3',
label=_('Priority'),
help_text=_('Please select a priority carefully. If unsure, leave it '
'as \'3\'.'),
)
submitter_email = forms.EmailField(
required=False,
label=_('Submitter E-Mail Address'),
help_text=_('This e-mail address will receive copies of all public '
'updates to this ticket.'),
)
body = forms.CharField(
widget=forms.widgets.Textarea(attrs={
'rows': 5,
'class': 'input-large span9'
}),
label=_('Description of Issue'),
required=True,
)
hidden_comment = forms.CharField(
label=_('Hidden comment'),
required=False,
widget=forms.widgets.Textarea(attrs={
'rows': 3,
'class': 'input-large span9'
}))
attachment = forms.FileField(
required=False,
label=_('Attach File'),
help_text=
_('You can attach a file such as a document or screenshot to this ticket.'
),
)
if HAS_TAG_SUPPORT:
tags = forms.CharField(
max_length=255,
required=False,
widget=forms.TextInput(),
label=_('Tags'),
help_text=_(
'Words, separated by spaces, or phrases separated by commas. '
'These should communicate significant characteristics of this '
'ticket'),
)
def save(self, user):
"""
Writes and returns a Ticket() object
"""
q = self.cleaned_data['queue']
t = Ticket(title=self.cleaned_data['title'],
submitter_email=self.cleaned_data['submitter_email'],
account=self.cleaned_data['account'],
created=datetime.now(),
status=Ticket.OPEN_STATUS,
queue=q,
description=self.cleaned_data['body'],
priority=self.cleaned_data['priority'],
owner=self.cleaned_data['owner'])
if HAS_TAG_SUPPORT:
t.tags = self.cleaned_data['tags']
if self.cleaned_data['assigned_to']:
try:
t.assigned_to = self.cleaned_data['assigned_to']
except User.DoesNotExist:
t.assigned_to = None
t.save()
f = FollowUp(
ticket=t,
title=_('Ticket Opened'),
date=datetime.now(),
public=False,
comment=self.cleaned_data['body'],
systemuser=user.account,
)
if self.cleaned_data['assigned_to']:
f.title = _('Ticket Opened & Assigned to %(name)s') % {
'name': t.get_assigned_to
}
f.save()
files = []
if self.cleaned_data['attachment']:
import mimetypes
file = self.cleaned_data['attachment']
filename = file.name.replace(' ', '_')
a = Attachment(
followup=f,
filename=filename,
mime_type=mimetypes.guess_type(filename)[0]
or 'application/octet-stream',
size=file.size,
)
a.file.save(file.name, file, save=False)
a.save()
if file.size < getattr(settings, 'MAX_EMAIL_ATTACHMENT_SIZE',
512000):
# Only files smaller than 512kb (or as defined in
# settings.MAX_EMAIL_ATTACHMENT_SIZE) are sent via email.
files.append(a.file.path)
context = {
'ticket': t,
'queue': q,
'comment': f.comment,
}
messages_sent_to = []
if t.submitter_email:
send_templated_mail(
'newticket_owner',
context,
recipients=t.submitter_email,
sender=q.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(t.submitter_email)
#FIX USERSETTINGS
#=======================================================================
# if t.assigned_to and t.assigned_to != user and getattr(t.assigned_to.usersettings.settings, 'email_on_ticket_assign', False) and t.assigned_to.email and t.assigned_to.email not in messages_sent_to:
# send_templated_mail(
# 'assigned_to',
# context,
# recipients=t.assigned_to.email,
# sender=q.from_address,
# fail_silently=True,
# files=files,
# )
# messages_sent_to.append(t.assigned_to.email)
#=======================================================================
if q.new_ticket_cc and q.new_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=q.new_ticket_cc,
sender=q.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(q.new_ticket_cc)
if q.updated_ticket_cc and q.updated_ticket_cc != q.new_ticket_cc and q.updated_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=q.updated_ticket_cc,
sender=q.from_address,
fail_silently=True,
files=files,
)
return t
def field(self):
from wagtail.wagtailadmin.widgets import AdminDateTimeInput
field_kwargs = {'widget': AdminDateTimeInput}
field_kwargs.update(self.field_options)
return forms.DateTimeField(**field_kwargs)
class UpdateCustomerPackageForm(forms.Form):
posted = forms.DateTimeField(required=False)
postage_cost = forms.DecimalField(required=False)
postage_currency = forms.ChoiceField(required=False,
choices=Currency.objects.all())
class PostForm(forms.Form):
content = forms.CharField(max_length=256)
created_at = forms.DateTimeField()
class ReviewsFrom(forms.ModelForm)
m
name = forms.CharField(max_length= 100)
details = forms.CharField(widget=forms.Textarea)
date = forms.DateTimeField(required=True, input_formats=["%Y-%m-%dT%H:%M"])
class TestForm(forms.Form):
char = forms.CharField(max_length=255)
hidden = forms.CharField(max_length=255, widget=forms.HiddenInput())
date = forms.DateField(widget=AdminDateWidget())
datetime = forms.DateTimeField(widget=AdminSplitDateTime())
class zvn_form_edit(forms.Form):
coment = forms.CharField(label='Коментарий:')
date_pr_call = forms.DateTimeField(label='Перезвонить в:')
class ElectionTimeExtensionForm(forms.Form):
voting_extended_until = forms.DateTimeField(help_text = _("UTC date and time voting extended to"),
label = _("Voting extended until"),
input_formats=['%d/%m/%Y %H:%M'],
widget=forms.DateTimeInput(format='%d/%m/%Y %H:%M'),
required=False)
class APIPostForm(forms.ModelForm):
title = forms.CharField(max_length=200, required=True)
content = forms.CharField(required=False)
slug = forms.SlugField(max_length=75, required=False)
status = forms.ChoiceField(
choices=STATUS_CHOICES,
error_messages={
'invalid_choice':
'Please use a valid status. Valid choices are %s' %
VALID_STATUS_CHOICES
})
publish_dt = forms.DateTimeField(required=False)
create_dt = forms.DateTimeField(required=False)
update_dt = forms.DateTimeField(required=False)
class Meta:
model = Post
def __init__(self, *args, **kwargs):
self.user = None
if 'user' in kwargs:
self.user = kwargs.pop('user', None)
# call the original init
super(APIPostForm, self).__init__(*args, **kwargs)
# order the fields so that the clean_field gets called in
# a specific order which makes validation easier
ordered_fields = OrderedDict([
(
'title',
self.fields['title'],
),
(
'content',
self.fields['content'],
),
(
'slug',
self.fields['slug'],
),
(
'publish_dt',
self.fields['publish_dt'],
),
(
'status',
self.fields['status'],
),
(
'create_dt',
self.fields['create_dt'],
),
(
'update_dt',
self.fields['update_dt'],
),
])
self.fields = ordered_fields
def clean_slug(self):
slug = self.cleaned_data['slug']
title = self.cleaned_data['title']
# autogenerate a slug if it isn't provided
if not self.instance.pk and not slug:
slug = slugify(title)
posts = Post.objects.filter(slug=slug, author=self.user)
if len(posts) > 0:
if self.instance.pk:
for post in posts:
if post.pk == self.instance.pk:
return slug
dup_post = posts[0]
msg = 'You already have a post with this slug "%s" (id: %d)' % (
slug, dup_post.pk)
raise forms.ValidationError(msg)
return slug
def clean_status(self):
status = self.cleaned_data['status']
publish_dt = None
if 'publish_dt' in self.cleaned_data:
publish_dt = self.cleaned_data['publish_dt']
if status == 'published' and not publish_dt:
raise forms.ValidationError(
'Please set the publish date/time (publish_dt) if status is set to published. Note that publish_dt is in UTC. (GMT)'
)
return status
class CreditCardPayForm(forms.Form):
datetime = forms.DateTimeField(required=True)
operations_id = forms.CharField(widget=forms.HiddenInput())
amount = forms.DecimalField(widget=forms.HiddenInput())
class PostForm(forms.ModelForm):
content = forms.CharField(
widget=forms.Textarea(attrs={'class': 'wmd-input'}), required=False)
publish_dt = forms.DateTimeField(input_formats=['%a, %b %d %Y %I:%M %p'],
required=False)
class Meta:
model = Post
def clean_slug(self):
slug = self.cleaned_data['slug']
posts = Post.objects.filter(slug=slug, author=self.user)
if len(posts) > 0:
if self.instance:
for post in posts:
if post.pk == self.instance.pk:
return slug
msg = 'You already have a post with this slug "%s"' % (slug)
raise forms.ValidationError(msg)
return slug
def clean_publish_dt(self):
date = self.cleaned_data['publish_dt']
if date:
date = localize_date(date,
from_tz=self.timezone,
to_tz=settings.TIME_ZONE)
return date
def __init__(self, *args, **kwargs):
# checking for user argument here for a more
# localized form
self.user = None
self.timezone = None
if 'user' in kwargs:
self.user = kwargs.pop('user', None)
super(PostForm, self).__init__(*args, **kwargs)
# add span class to charfields
for field in self.fields.values():
if isinstance(field, forms.fields.CharField):
if 'class' in field.widget.attrs:
field.widget.attrs['class'] = "%s %s" % (
field.widget.attrs['class'],
'span8',
)
else:
field.widget.attrs['class'] = 'span8'
# disable publish_dt if draft
if not self.instance.status or self.instance.status == 'draft':
self.fields['publish_dt'].widget.attrs['disabled'] = 'disabled'
# get the published dt
publish_dt = self.instance.publish_dt
if not publish_dt:
publish_dt = datetime.now()
# adjust the date/time to the users preference
if self.user and not self.user.is_anonymous():
user_settings = Setting.objects.get(user=self.user)
self.timezone = user_settings.timezone
publish_dt = localize_date(publish_dt, to_tz=self.timezone)
else:
self.timezone = 'US/Central'
publish_dt = localize_date(publish_dt, to_tz=self.timezone)
self.initial['publish_dt'] = publish_dt
class AddDomainForm(forms.Form):
"""
Django form for adding a domain.
"""
error_css_class = 'error'
required_css_class = 'required'
domain = forms.CharField(label=form_consts.Domain.DOMAIN_NAME)
campaign = forms.ChoiceField(widget=forms.Select, required=False,
label=form_consts.Domain.CAMPAIGN)
confidence = forms.ChoiceField(required=False, label=form_consts.Domain.CAMPAIGN_CONFIDENCE)
domain_source = forms.ChoiceField(required=True,
widget=forms.Select(attrs={'class': 'bulknoinitial'}),
label=form_consts.Domain.DOMAIN_SOURCE)
domain_method = forms.CharField(required=False,
widget=forms.TextInput,
label=form_consts.Domain.DOMAIN_METHOD)
domain_reference = forms.CharField(widget=forms.TextInput(attrs={'size':'90'}),
required=False,
label=form_consts.Domain.DOMAIN_REFERENCE)
add_ip = forms.BooleanField(required=False,
widget=forms.CheckboxInput(attrs={'class':'bulkskip'}),
label=form_consts.Domain.ADD_IP_ADDRESS)
ip = forms.GenericIPAddressField(required=False,
label=form_consts.Domain.IP_ADDRESS,
widget=forms.TextInput(attrs={'class': 'togglewithip bulkrequired'}))
ip_type = forms.ChoiceField(required=False,
label=form_consts.IP.IP_TYPE,
widget=forms.Select(attrs={'class':'togglewithip bulkrequired bulknoinitial'}),)
created = forms.DateTimeField(widget=CalWidget(format=settings.PY_DATETIME_FORMAT,
attrs={'class':'datetimeclass togglewithip bulkrequired',
'size':'25',
'id':'id_domain_ip_date'}),
input_formats=settings.PY_FORM_DATETIME_FORMATS,
required=False,
label=form_consts.Domain.IP_DATE)
same_source = forms.BooleanField(required=False,
widget=forms.CheckboxInput(attrs={'class':'togglewithip bulkskip'}),
label=form_consts.Domain.SAME_SOURCE)
ip_source = forms.ChoiceField(required=False,
widget=forms.Select(attrs={'class':'togglewithipsource togglewithip bulkrequired bulknoinitial'}),
label=form_consts.Domain.IP_SOURCE)
ip_method = forms.CharField(required=False,
widget=forms.TextInput(attrs={'class':'togglewithipsource togglewithip'}),
label=form_consts.Domain.IP_METHOD)
ip_reference = forms.CharField(widget=forms.TextInput(attrs={'size':'90',
'class':'togglewithipsource togglewithip'}),
required=False,
label=form_consts.Domain.IP_REFERENCE)
add_indicators = forms.BooleanField(required=False,
widget=forms.CheckboxInput(attrs={'class':'bulkskip'}),
label=form_consts.Domain.ADD_INDICATOR)
def __init__(self, username, *args, **kwargs):
super(AddDomainForm, self).__init__(*args, **kwargs)
self.fields['domain_source'].choices = self.fields['ip_source'].choices = [(c.name, c.name) for c in get_source_names(True, True, username)]
self.fields['domain_source'].initial = get_user_organization(username)
self.fields['ip_source'].initial = get_user_organization(username)
self.fields['campaign'].choices = [('', '')] + [(c.name, c.name) for c in get_item_names(Campaign, True)]
self.fields['confidence'].choices = [('',''),
('low', 'low'),
('medium', 'medium'),
('high', 'high')]
self.fields['ip_type'].choices = ip_choices
self.fields['ip_type'].initial = "Address - ipv4-addr"
add_bucketlist_to_form(self)
add_ticket_to_form(self)
def clean(self):
cleaned_data = super(AddDomainForm, self).clean()
add_ip = cleaned_data.get('add_ip')
ip = cleaned_data.get('ip')
date = cleaned_data.get('created')
same_source = cleaned_data.get('same_source')
ip_source = cleaned_data.get('ip_source')
ip_type = cleaned_data.get('ip_type')
campaign = cleaned_data.get('campaign')
if campaign:
confidence = cleaned_data.get('confidence')
if not confidence or confidence == '':
self._errors.setdefault('confidence', ErrorList())
self._errors['confidence'].append(u'This field is required if campaign is specified.')
if add_ip:
if not ip:
self._errors.setdefault('ip', ErrorList())
self._errors['ip'].append(u'This field is required.')
if not ip_type:
self._errors.setdefault('ip_type', ErrorList())
self._errors['ip_type'].append(u'This field is required.')
if not date:
self._errors.setdefault('created', ErrorList())
self._errors['created'].append(u"This field is required.") #add error to created field
if not (same_source or ip_source):
self._errors.setdefault('same_source', ErrorList())
self._errors['same_source'].append(u"This field is required.") #add error to IP source field
if not same_source and not ip_source:
self._errors.setdefault('ip_source', ErrorList())
self._errors['ip_source'].append(u"This field is required.") #add error to IP source field
return cleaned_data
import six
from django import forms
from ..backends.plain import PlainFilterBackend
from ..exceptions import SkipFilter
from ..filters import Filter
from ..utils import SubClassDict, dictify
from .base import BaseModelFilterSet
DATA_TYPES_MAPPING = SubClassDict({
six.string_types: forms.CharField(),
six.integer_types: forms.IntegerField(),
bool: forms.BooleanField(required=False),
float: forms.FloatField(),
Decimal: forms.DecimalField(),
datetime: forms.DateTimeField(),
date: forms.DateField(),
time: forms.TimeField(),
})
class PlainModelFilterSet(BaseModelFilterSet):
"""
:class:`.FilterSet` for plain Python objects.
The filterset can be configured via ``Meta`` class attribute,
very much like Django's ``ModelForm`` is configured.
"""
filter_backend_class = PlainFilterBackend
def _build_state(self):
class addPost(forms.Form):
message = forms.CharField(widget=forms.TextInput, max_length=280)
submitDate = forms.DateTimeField(timezone.now)
class AbstractTicketForm(CustomFieldMixin, forms.Form):
"""
Contain all the common code and fields between "TicketForm" and
"PublicTicketForm". This Form is not intended to be used directly.
"""
queue = forms.ChoiceField(
widget=forms.Select(attrs={'class': 'form-control'}),
label=_('Queue'),
required=True,
choices=())
title = forms.CharField(
max_length=100,
required=True,
widget=forms.TextInput(attrs={'class': 'form-control'}),
label=_('Summary of the problem'),
)
body = forms.CharField(
widget=forms.Textarea(attrs={'class': 'form-control'}),
label=_('Description of your issue'),
required=True,
help_text=_(
'Please be as descriptive as possible and include all details'),
)
priority = forms.ChoiceField(
widget=forms.Select(attrs={'class': 'form-control'}),
choices=Ticket.PRIORITY_CHOICES,
required=True,
initial='3',
label=_('Priority'),
help_text=_(
"Please select a priority carefully. If unsure, leave it as '3'."),
)
due_date = forms.DateTimeField(
widget=forms.TextInput(attrs={'class': 'form-control'}),
required=False,
label=_('Due on'),
)
attachment = forms.FileField(
required=False,
label=_('Attach File'),
help_text=
_('You can attach a file such as a document or screenshot to this ticket.'
),
)
def _add_form_custom_fields(self, staff_only_filter=None):
if staff_only_filter is None:
queryset = CustomField.objects.all()
else:
queryset = CustomField.objects.filter(staff_only=staff_only_filter)
for field in queryset:
instanceargs = {
'label': field.label,
'help_text': field.help_text,
'required': field.required,
}
self.customfield_to_field(field, instanceargs)
def _create_ticket(self):
queue = Queue.objects.get(id=int(self.cleaned_data['queue']))
ticket = Ticket(
title=self.cleaned_data['title'],
submitter_email=self.cleaned_data['submitter_email'],
created=timezone.now(),
status=Ticket.OPEN_STATUS,
queue=queue,
description=self.cleaned_data['body'],
priority=self.cleaned_data['priority'],
due_date=self.cleaned_data['due_date'],
)
return ticket, queue
def _create_custom_fields(self, ticket):
for field, value in self.cleaned_data.items():
if field.startswith('custom_'):
field_name = field.replace('custom_', '', 1)
custom_field = CustomField.objects.get(name=field_name)
cfv = TicketCustomFieldValue(ticket=ticket,
field=custom_field,
value=value)
cfv.save()
def _create_follow_up(self, ticket, title, user=None):
followup = FollowUp(
ticket=ticket,
title=title,
date=timezone.now(),
public=True,
comment=self.cleaned_data['body'],
)
if user:
followup.user = user
return followup
def _attach_files_to_follow_up(self, followup):
files = self.cleaned_data['attachment']
if files:
files = process_attachments(followup, [files])
return files
@staticmethod
def _send_messages(ticket, queue, followup, files, user=None):
context = safe_template_context(ticket)
context['comment'] = followup.comment
messages_sent_to = []
if ticket.submitter_email:
send_templated_mail(
'newticket_submitter',
context,
recipients=ticket.submitter_email,
sender=queue.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(ticket.submitter_email)
if ticket.assigned_to and \
ticket.assigned_to != user and \
ticket.assigned_to.usersettings_hldesk.settings.get('email_on_ticket_assign', False) and \
ticket.assigned_to.email and \
ticket.assigned_to.email not in messages_sent_to:
send_templated_mail(
'assigned_owner',
context,
recipients=ticket.assigned_to.email,
sender=queue.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(ticket.assigned_to.email)
if queue.new_ticket_cc and queue.new_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=queue.new_ticket_cc,
sender=queue.from_address,
fail_silently=True,
files=files,
)
messages_sent_to.append(queue.new_ticket_cc)
if queue.updated_ticket_cc and \
queue.updated_ticket_cc != queue.new_ticket_cc and \
queue.updated_ticket_cc not in messages_sent_to:
send_templated_mail(
'newticket_cc',
context,
recipients=queue.updated_ticket_cc,
sender=queue.from_address,
fail_silently=True,
files=files,
)
class create_estimates(forms.Form):
estimate_type = forms.ChoiceField(
choices=sale_type,
widget=forms.Select(attrs={
'class': 'form-control',
'id': 'sale_type_id'
}))
estimate_date = forms.DateTimeField(widget=forms.DateInput(
attrs={
'class': 'form-control',
'type': 'date',
'id': 'startDate'
}))
# sale_time=forms.DateTimeField(widget=forms.TimeInput(attrs={'class':'form-control','type':'time','id':'startTime','step':"1"}))
estimate_sub_total = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "final_subtotal",
'readonly': "readonly",
"type": "hidden"
}))
estimate_tax_amount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "final_taxtotal",
'readonly': "readonly",
"type": "hidden"
}))
estimate_discount_amount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "final_disctotal",
'readonly': "readonly",
"type": "hidden"
}))
# qtysale_sub_total=forms.CharField(widget=forms.NumberInput(attrs={'class':'form-control','value':"0","step":"0.01",'id':"qtyfinal_subtotal",'readonly':"readonly","type":"hidden"}))
edit_tot = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "edit_tot",
'readonly': "readonly",
"type": "hidden"
}))
sp_discount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "sp_discount",
'readonly': "readonly",
"type": "hidden"
}))
estimate_credit = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "example-number-input"
}))
estimate_debit = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "example-number-input"
}))
estimate_special_discount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "special_discount_id",
'onclick': "this.select();"
}))
estimate_total = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "sale_tot",
"step": "0.01"
}))
estimate_payment_received = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "example-number-input"
}))
estimate_total_tax_amount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
"step": "0.01",
'id': "total_tax_id"
}))
estimate_total_discount_amount = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "total_discount_id"
}))
estimate_round_off = forms.CharField(widget=forms.NumberInput(
attrs={
'class': 'form-control',
'value': "0",
'id': "example-number-input"
}))
estimate_transaction_mode = forms.ChoiceField(
choices=transaction_mode,
widget=forms.Select(attrs={
'class': 'form-control',
}))
estimate_cash_account = forms.ChoiceField(
choices=cash_account,
widget=forms.Select(attrs={
'class': 'form-control',
}))
class user_news_story(ModelForm):
date = forms.DateTimeField(required=False, widget=forms.SelectDateWidget)
class Meta:
model = new_by_viewer
fields = ["title", "image", "date", "author", "info"]
class StockTransactionFilterForm(forms.Form):
stock_item = forms.CharField(required=False)
category = forms.ChoiceField(required=False,
label='Category',
choices=[('', '--- Select Category ---')] +
list(StockItem.STOCK_CATEGORIES))
start_date = forms.DateTimeField(required=False, label='Start date')
end_date = forms.DateTimeField(required=False, label='End date')
transaction_type = forms.ChoiceField(
required=False,
label='Category',
choices=[('', '--- Select Transaction Type ---')] +
list(StockTransaction.STOCK_TRANSACTION_TYPES))
district = forms.ChoiceField(
required=False,
label='District',
choices=[('', '--- Select District ---')] +
list(Branch.objects.all().values_list('id', 'description')))
supplier = forms.CharField(required=False)
def __init__(self, *args, **kwargs):
super(StockTransactionFilterForm, self).__init__(*args, **kwargs)
self.fields['end_date'].widget.attrs['class'] = 'date_field'
self.fields['start_date'].widget.attrs['class'] = 'date_field'
self.fields['start_date'].widget.attrs['placeholder'] = 'Start Date'
self.fields['end_date'].widget.attrs['placeholder'] = 'End Date'
def filter(self, stock_items):
if self.cleaned_data is not None:
if self.cleaned_data['stock_item']:
stock_items = stock_items.filter(
stock_item__item_name__icontains=self.
cleaned_data['stock_item'])
if self.cleaned_data['category']:
stock_items = stock_items.filter(
stock_item__category=self.cleaned_data['category'])
if self.cleaned_data['transaction_type']:
stock_items = stock_items.filter(
transaction_type=self.cleaned_data['transaction_type'])
if self.cleaned_data['start_date']:
stock_items = stock_items.filter(
transaction_date__gte=self.cleaned_data['start_date'])
if self.cleaned_data['end_date']:
stock_items = stock_items.filter(
transaction_date__lte=self.cleaned_data['end_date'])
if self.cleaned_data['district']:
stock_items = stock_items.filter(
district=self.cleaned_data['district'])
if self.cleaned_data['supplier']:
suppliers = Vendor.objects.filter(name__icontains=self.cleaned_data['supplier'])\
.values_list('id', flat=True)
stock_items = stock_items.filter(supplier_id__in=suppliers)
return stock_items
class BookingForm(forms.ModelForm):
"""
Django form for the Booking model
"""
class Meta:
model = Booking
fields = ["title", "start_date", "end_date", "resource"]
start_date = forms.DateTimeField(
label=_("From"),
input_formats=["%d/%m/%Y %H:%M"],
widget=forms.DateTimeInput(
attrs={
"class": "form-control datetimepicker-input",
"data-target": "#id_start_date",
"data-toggle": "datetimepicker",
"autocomplete": "off",
}
),
)
end_date = forms.DateTimeField(
label=_("To"),
input_formats=["%d/%m/%Y %H:%M"],
widget=forms.DateTimeInput(
attrs={
"class": "form-control datetimepicker-input",
"data-target": "#id_end_date",
"data-toggle": "datetimepicker",
"autocomplete": "off",
}
),
)
def clean(self):
"""
Custom form validation
"""
cleaned_data = super().clean()
# Check if the edited or created booking is not in the past (or currently effective)
if timezone.now() > cleaned_data.get("start_date"):
raise ValidationError(
_("Start date cannot be in the past"), code="start_date_past"
)
# Check if start_date is before end_date
if cleaned_data.get("end_date") < cleaned_data.get("start_date"):
raise ValidationError(
_("Start date cannot be after end date"), code="end_before_start"
)
# Check if the dates don't overlap an existing booking
if Booking.check_overlap(
cleaned_data.get("resource"),
cleaned_data["start_date"],
cleaned_data["end_date"],
):
raise ValidationError(
_("The resource is not available during this time range"),
code="not_available",
)
def _attr_datetime_field(attribute):
return forms.DateTimeField(label=attribute.name,
required=attribute.required,
widget=DateTimePickerInput())
class addtodo(forms.Form):
name = forms.CharField(max_length=100)
description = forms.CharField(max_length=500)
created = forms.DateTimeField(widget=forms.TextInput(
attrs={'placeholder': 'yyyy-mm-dd'}))
class DocumentoForm(ModelForm):
parlamentares = ModelMultipleChoiceField(
queryset=Parlamentar.objects.filter(ativo=True),
required=False,
label=Parlamentar._meta.verbose_name_plural,
widget=forms.SelectMultiple(attrs={'size': '10'}))
public_date = forms.DateTimeField(
widget=forms.HiddenInput(),
required=False,
)
tipo = forms.ChoiceField(choices=Documento.tipo_parte_doc['documentos'])
capa = forms.TypedChoiceField(label=_('Capa de sua Classe'),
choices=YES_NO_CHOICES,
coerce=lambda x: x == 'True')
materias = ModelMultipleChoiceField(
queryset=MateriaLegislativa.objects.order_by('-data_apresentacao'),
required=False,
label=MateriaLegislativa._meta.verbose_name_plural,
widget=forms.SelectMultiple(attrs={'size': '10'}))
class Meta:
model = Documento
fields = [
'titulo', 'template_doc', 'descricao', 'visibilidade',
'parlamentares', 'public_date', 'tipo', 'listar', 'capa',
'materias'
]
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.layout = SaplFormLayout(
to_row([('titulo', 7), ('visibilidade', 3), ('listar', 2)]),
to_row([
('tipo', 4),
('template_doc', 4),
('capa', 4),
]),
to_row([('descricao', 8), ('parlamentares', 4)]),
to_row([
('materias', 12),
]),
)
super(DocumentoForm, self).__init__(*args, **kwargs)
self.fields['parlamentares'].choices = [
('0', '--------------')
] + list(self.fields['parlamentares'].choices)
self.fields['materias'].choices = [('0', '--------------')] + [
(m.id, str(m) + ' - ' + m.ementa)
for m in self.fields['materias'].queryset[:200]
]
self.fields[
'capa'].initial = self.instance == self.instance.classe.capa
def save(self, commit=True):
inst = self.instance
if inst.visibilidade != Documento.STATUS_PUBLIC:
inst.public_date = None
inst.public_end_date = None
else:
if not inst.public_date:
inst.public_date = timezone.now()
inst = super().save(commit)
if not inst.childs.exists():
container = Documento()
container.titulo = ''
container.descricao = ''
container.classe = inst.classe
container.tipo = Documento.TPD_CONTAINER_SIMPLES
container.owner = inst.owner
container.parent = inst
container.ordem = 1
container.visibilidade = inst.visibilidade
container.save()
classe = inst.classe
classe.capa = inst if self.cleaned_data['capa'] else None
classe.save()
return inst
class NewEventForm(forms.Form):
gapLength = forms.DurationField(label="długość przedziału czasu",
required=False)
name = forms.CharField(label="nazwa", max_length=50, required=False)
begin = forms.DateTimeField(label="początek", required=False)
end = forms.DateTimeField(label="koniec", required=False)
u1 = forms.CharField(label="użytkownik 1", max_length=50, required=False)
userFieldNr = forms.CharField(widget=forms.HiddenInput(), initial=1)
def ensure_user_field_nr(self, uNr):
"""zapewnij odpowiednią liczbę pól na zaproszonych użytkowników"""
for i in range(1, uNr + 1):
key = 'u' + str(i)
if key not in self.fields:
self.fields[key] = forms.CharField(label="użytkownik " +
str(i),
max_length=50,
required=False)
else:
pass
def getUnames(self, uNr):
"""weź nazwy zaproszony użytkowników"""
u = set()
for i in range(1, uNr + 1):
u.add(self.cleaned_data['u' + str(i)].strip())
return u
def find_gap_plan(self, uNr):
"""znajdź pierwszy wolny termin że nie powiedzieli że uczestniczą"""
gap = parse_duration(self.data['gapLength'])
self.checkNames(uNr)
if not gap:
self.add_error('gapLength', 'Nie podano długości przedziału:')
if self.errors:
return False
unames = self.getUnames(uNr)
planned = Invitation.objects.filter(user__name__in=unames,
reactionType=1)
# czas kompa, może być inny niby niż czas bazy, ale zał. że jest ok;
# żeby znalazł teraz jeśli się uda
tab = [(datetime.now(pytz.utc), 0)]
for p in planned:
p_begin = p.meeting.begin
p_end = p.meeting.end
tab.append((p_begin, +1))
tab.append((p_end, -1))
gap_begin = find_first_gap(gap, sorted(tab))
self.data['begin'] = gap_begin
self.data['end'] = gap_begin + gap
return True
def find_gap_inv(self, uNr):
"""znajdż pierwszy wolny termin że mogą tam mieć tylko 'nie wiem' albo 'nie wezmę udziału'"""
gap = parse_duration(self.data['gapLength'])
self.checkNames(uNr)
if not gap:
self.add_error('gapLength', 'Nie podano długości przedziału:')
if self.errors:
return False
unames = self.getUnames(uNr)
possibly_want = set()
possibly_want.add(1)
possibly_want.add(2)
possibly_want.add(3)
invitations = Invitation.objects.filter(
user__name__in=unames,
reactionType__in=possibly_want) # wszystkie co raczej chcą
# czas kompa, może być inny niby niż czas bazy, ale zał. że jest ok;
# żeby znalazł teraz jeśli się uda
tab = [(datetime.now(pytz.utc), 0)]
for p in invitations:
p_begin = p.meeting.begin
p_end = p.meeting.end
tab.append((p_begin, +1))
tab.append((p_end, -1))
gap_begin = find_first_gap(gap, sorted(tab))
self.data['begin'] = gap_begin
self.data['end'] = gap_begin + gap
return True # newform
@transaction.atomic
# każde żądanie jest transakcją, dekorator został z kiedy tylko to było
def create_event(self, myuId, uNr):
"""dodaj potrzebne rekordy w bazie danych - utwórz wydarzenie"""
# to nie może łapać wyjątku w środku jak z dekoratorem, musi być łapany na zewnątrz
name1 = self.cleaned_data['name']
begin1 = self.cleaned_data['begin']
end1 = self.cleaned_data['end']
myu = User.objects.get(id=myuId)
# zakładam że twórca wydarzenia niekoniecznie musi na nie iść, i traktuję go jako każdego innego
# w szczególności może go w ogóle nie być w uczestnikach
meet = Meeting.objects.create(name=name1,
begin=begin1,
end=end1,
invitedNr=uNr,
acceptedNr=0,
creator=myu)
for i in range(1, uNr + 1):
uname = self.cleaned_data['u' + str(i)].strip()
u = User.objects.get(name=uname) # name to klucz, więc możemy tak
InviteInfo.objects.create(user=u, meeting=meet)
# 3 to że jeszcze nie zareagował
Invitation.objects.create(user=u, meeting=meet, reactionType=3)
def checkNames(self, uNr):
"""sprawdź czy podane nazwy użytkowników są ok"""
d = set()
for i in range(1, uNr + 1):
if 'u' + str(i) in self.cleaned_data:
uname = self.cleaned_data['u' + str(i)].strip()
self.cleaned_data['u' + str(i)] = uname
if uname in d:
self.add_error('u' + str(i),
'Nazwa użytkownika się powtarza:')
else:
try:
# name to klucz, więc możemy tak
User.objects.get(name=uname)
except BaseException:
self.add_error('u' + str(i),
'Użytkownik nie istnieje:')
if uname:
d.add(uname)
else:
self.add_error('u' + str(i), 'Nie podano użytkownika:')
def checkClean(self, uNr):
"""funkcja sprawdzająca czy formularz ma poprawne dane, elastyczniejsza
od zwykłego clean, bo może mieć dodatkowy argument; dodaje błędy przy polach"""
self.checkNames(uNr)
if 'begin' in self.cleaned_data:
b = self.cleaned_data['begin']
if not b:
self.add_error('begin', 'Brak podanego czasu rozpoczęcia:')
if 'end' in self.cleaned_data:
b = self.cleaned_data['end']
if not b:
self.add_error('end', 'Brak podanego czasu zakończenia:')
if 'name' in self.cleaned_data:
n = self.cleaned_data['name'].strip()
self.cleaned_data['name'] = n
if not n:
self.add_error('name',
'Nazwa wydarzenia zawiera same białe znaki')
else:
self.add_error('name', 'Brakuje nazwy')
def clean(self):
"""nadpisana funkcja sprawdzająca dane formularza, żeby można było np. sobie
class FilterForm(forms.Form):
date_start = forms.DateTimeField(
label=_(u'Создана с'),
required=False,
widget=forms.widgets.DateTimeInput(attrs={'class': 'datepicker'}))
date_end = forms.DateTimeField(
label=_(u'Создана по'),
required=False,
widget=forms.widgets.DateTimeInput(attrs={'class': 'datepicker'}))
queue = forms.ModelMultipleChoiceField(queryset=Queue.objects.all(),
required=False)
status = forms.ChoiceField(choices=Ticket.STATUS_CHOICES_FORM,
required=False,
label=_(u'Статус'))
priority = forms.ChoiceField(choices=Ticket.PRIORITY_CHOICES_FORM,
required=False,
label=_(u'Приоритет'))
owner = forms.ModelChoiceField(queryset=User.objects.all(),
required=False,
label=_(u'Подал заявку'),
widget=autocomplete_light.ChoiceWidget(
'UserAutocomplete',
attrs={'class': 'span6 input'}))
account = forms.ModelChoiceField(queryset=Account.objects.all(),
required=False,
label=_(u'Аккаунт'),
widget=autocomplete_light.ChoiceWidget(
'AccountAutocomplete',
attrs={'class': 'span6 input'}))
assigned_to = forms.ModelMultipleChoiceField(
queryset=SystemUser.objects.all(), required=False)
#===========================================================================
# tags = TagChoices(
# required=False,
# label=_(u'Тэги'),
# help_text=_(u'Укажите набор тэгов, которые были присвоены нужным вам задачам.'),
# widget=AutoHeavySelect2Widget(
# select2_options={
# 'width': '50%',
# 'placeholder': u"Тэги"
# }
# )
# )
#===========================================================================
keywords = forms.CharField(
label=_(u'Фраза'),
help_text=_(u'Поиск по тексту заголовков и заявок'),
required=False)
filter_name = forms.CharField(label=_(u'Имя фильтра'), required=False)
share_filter = forms.BooleanField(label=_(u'Расшарить фильтр'),
required=False)
saved_query = forms.ModelChoiceField(label=_(u'Сохранённые фильтры'),
required=False,
queryset=SavedSearch.objects.filter(
Q(shared=True)))
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.form_id = 'id-followup_form'
self.helper.form_class = 'well form-horizontal ajax form-condensed'
self.helper.form_method = 'post'
self.helper.form_tag = False
self.helper.form_action = reverse("followup_edit")
ft = kwargs.get('initial', {}).get('followup_type')
self.helper.layout = Layout(
Fieldset(
_(u'Параметры поиска'),
'date_start',
'date_end',
'queue',
'status',
'priority',
'owner',
'account',
'assigned_to',
#'tags',
Field('keywords', css_class='input-large span6'),
),
Div(Submit('search',
_(u'Найти заявки'),
css_class="btn-primary btn-large "),
css_class='form-actions-center'),
Fieldset(
_(u'Сохранить запрос'),
'filter_name',
'share_filter',
Div(Submit('save',
_(u'Сохранить и выполнить фильтр'),
css_class="btn-primary btn-large "),
css_class='form-actions-center'),
),
Fieldset(
_(u'Использовать сохранённый запрос'),
'saved_query',
Div(Submit('run',
_(u'Выполнить'),
css_class="btn-primary btn-large "),
css_class='form-actions-center'),
),
)
super(FilterForm, self).__init__(*args, **kwargs)
class SearchBookingForm(forms.Form):
arrival = forms.DateTimeField()
departure = forms.DateTimeField()
nbr_peoples = forms.IntegerField()
class SharerSearchForm(forms.Form):
dst = forms.CharField()
early_time = forms.DateTimeField(help_text='Format: 2020-01-01 12:00')
last_time = forms.DateTimeField(help_text='Format: 2020-01-01 12:00')
share_pass_num = forms.IntegerField()
class MessageSmsInsurancePolicyExpiresForm(forms.ModelForm):
created = forms.DateTimeField(input_formats=DATE_TIME_INPUT_FORMAT)
class Meta:
model = MessageSmsInsurancePolicyExpires
fields = ('created', 'sid', 'body', 'insurance_policy')
class ReportListForm(BaseForm):
all_param = 'ALL:ALL'
signature = form_fields.SignatureField(required=True)
product = forms.MultipleChoiceField(required=False)
version = forms.MultipleChoiceField(required=False)
date = forms.DateTimeField(required=False)
range_value = forms.IntegerField(required=False)
reason = forms.CharField(required=False)
release_channels = forms.CharField(required=False)
build_id = form_fields.BuildIdsField(required=False)
range_unit = forms.ChoiceField(required=False,
choices=make_choices(settings.RANGE_UNITS))
process_type = forms.ChoiceField(required=False,
choices=make_choices(
settings.PROCESS_TYPES))
hang_type = forms.ChoiceField(required=False,
choices=make_choices(settings.HANG_TYPES))
plugin_field = forms.ChoiceField(required=False,
choices=make_choices(
settings.PLUGIN_FIELDS))
plugin_query_type = forms.ChoiceField(required=False,
choices=make_choices(
settings.QUERY_TYPES))
plugin_query = forms.CharField(required=False)
def __init__(self, current_products, current_versions, *args, **kwargs):
super(ReportListForm, self).__init__(*args, **kwargs)
# Default values
products = [(x, x) for x in current_products]
versions = [(self.all_param, self.all_param)]
for version in current_versions:
v = '%s:%s' % (version['product'], version['version'])
versions.append((v, v))
self.fields['product'].choices = products
self.fields['version'].choices = versions
def clean_version(self):
versions = self.cleaned_data['version']
if self.all_param in versions:
versions.remove(self.all_param)
return versions
def clean_range_value(self):
value = self.cleaned_data['range_value']
if not value:
value = 1
elif value < 0:
raise forms.ValidationError(
'range_value must be a positive integer')
return value
def clean(self):
cleaned_data = super(ReportListForm, self).clean()
if 'product' in cleaned_data and 'version' in cleaned_data:
# check the invariant
# every product in versions must be a supplied product
for version in cleaned_data['version']:
if version.split(':')[0] not in cleaned_data['product']:
raise forms.ValidationError("Mismatched product %r" %
version)
return cleaned_data
class ElectionForm(forms.ModelForm):
class Meta:
model = Election
fields = [
"title",
"description",
"archived",
"start_candidature",
"end_candidature",
"start_date",
"end_date",
"edit_groups",
"view_groups",
"vote_groups",
"candidature_groups",
]
edit_groups = make_ajax_field(Election,
"edit_groups",
"groups",
help_text="",
label=_("edit groups"))
view_groups = make_ajax_field(Election,
"view_groups",
"groups",
help_text="",
label=_("view groups"))
vote_groups = make_ajax_field(Election,
"vote_groups",
"groups",
help_text="",
label=_("vote groups"))
candidature_groups = make_ajax_field(
Election,
"candidature_groups",
"groups",
help_text="",
label=_("candidature groups"),
)
start_date = forms.DateTimeField(
input_formats=["%Y-%m-%d %H:%M:%S"],
label=_("Start date"),
widget=SelectDateTime,
required=True,
)
end_date = forms.DateTimeField(
input_formats=["%Y-%m-%d %H:%M:%S"],
label=_("End date"),
widget=SelectDateTime,
required=True,
)
start_candidature = forms.DateTimeField(
input_formats=["%Y-%m-%d %H:%M:%S"],
label=_("Start candidature"),
widget=SelectDateTime,
required=True,
)
end_candidature = forms.DateTimeField(
input_formats=["%Y-%m-%d %H:%M:%S"],
label=_("End candidature"),
widget=SelectDateTime,
required=True,
)
