def __init__(self, *args, **kwargs):
"""mode argument is required for distinguish ajax sources"""
mode = kwargs.get('mode')
if mode:
del kwargs['mode']
else:
raise ModeNotSetException("mode argument not given.")
super(BasePartForm, self).__init__(*args, **kwargs)
channel = 'asset_dcdevice' if mode == 'dc' else 'asset_bodevice'
self.fields['device'] = AutoCompleteSelectField(
LOOKUPS[channel],
required=False,
help_text='Enter barcode, sn, or model.',
)
self.fields['source_device'] = AutoCompleteSelectField(
LOOKUPS[channel],
required=False,
help_text='Enter barcode, sn, or model.',
)
if self.instance.source_device:
self.fields[
'source_device'].initial = self.instance.source_device.id
if self.instance.device:
self.fields['device'].initial = self.instance.device.id
class BulkCreateForm(forms.Form):
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.form_class = "form-horizontal"
self.helper.form_method = "GET"
self.helper.layout = Layout(
Field('contact'), Field('billing'),
Field(
'date_first',
css_class="datepick",
), Field(
'date_second',
css_class="datepick",
), FormActions(Submit('save', 'Continue'), ))
super(BulkCreateForm, self).__init__(*args, **kwargs)
contact = AutoCompleteSelectField(
'Users',
required=True,
plugin_options={
'position':
"{ my : \"right top\", at: \"right bottom\", of: \"#id_person_name_text\"},'minlength':4"
})
billing = AutoCompleteSelectField(
'Orgs',
required=True,
plugin_options={
'position':
"{ my : \"right top\", at: \"right bottom\", of: \"#id_person_name_text\"},'minlength':4"
})
date_first = forms.DateField(label="Date of first movie")
date_second = forms.DateField(label="Date of last movie")
class SGAEditorForm(forms.Form):
#warningwords = forms.ModelChoiceField(queryset=WarningWord.objects.all(),
# label=_("Warning Word"))
dangerindication = AutoCompleteSelectField('dangerindication',
label=_("Danger Indication"))
prudenceadvice = AutoCompleteSelectField('prudenceadvices',
label=_("Prudence Advices"))
class CommissionForm(ModelForm):
author = AutoCompleteSelectField("authors",
required=False,
help_text=None,
label="Payee")
article = AutoCompleteSelectField('articles',
required=False,
help_text=None)
def clean_author(self):
data = self.cleaned_data['author']
if data is None:
raise forms.ValidationError("Please enter a user")
return data
class Meta:
model = Commission
fields = [
'author',
'article',
'description',
'notes',
'commission_due',
'taxable',
'vatable',
'fund',
]
class CommissionForm(ModelForm):
author = AutoCompleteSelectField("authors",
required=False,
help_text=None,
label="Payee")
article = AutoCompleteSelectField('articles',
required=False,
help_text=None)
fund = forms.ModelChoiceField(
queryset=Fund.objects.filter(ledger=True).filter(deprecated=False),
label='Pastel',
required=False)
def clean_author(self):
data = self.cleaned_data['author']
if data is None:
raise forms.ValidationError("Please enter a user")
return data
class Meta:
model = Commission
fields = [
'author', 'article', 'fund', 'description', 'notes',
'commission_due', 'taxable', 'vatable', 'vat_amount'
]
class FormPessoa(MyModelForm):
def clean(self):
cleaned_data = self.cleaned_data
ini = cleaned_data.get('inicio_mandato')
fim = cleaned_data.get('fim_mandato')
if ini and fim and (ini > fim):
raise forms.ValidationError(
'O inicio do mandato não pode ser posterior ao fim do mandato!'
)
class Meta:
model = Pessoa
exclude = []
deputado = AutoCompleteSelectField('deputados',
label='Deputado',
help_text=None)
instituicao = AutoCompleteSelectField('instituicao',
label='Instituição',
help_text=None)
cargo = AutoCompleteSelectField('cargos', label='Cargo', help_text=None)
partido = AutoCompleteSelectField('partidos',
label='Partido',
help_text=None)
class BulkEmailForm(EmailForm):
group = forms.ChoiceField(choices=EMAIL_GROUPS)
institute = AutoCompleteSelectField('institute',
required=False,
label="Institute")
project = AutoCompleteSelectField('project',
required=False,
label="Project")
def get_person_query(self):
person_query = Person.active.all()
group = self.cleaned_data['group']
if group == 'leaders':
person_query = person_query.filter(leads__isnull=False)
elif group == 'users':
pass
elif group == 'cluster_users':
person_query = person_query.filter(account__isnull=False)
else:
person_query = None
institute = self.cleaned_data['institute']
if institute is not None:
person_query = person_query.filter(institute=institute)
project = self.cleaned_data['project']
if project is not None:
person_query = person_query.filter(groups__project=project)
return person_query
class PostulationForm(ModelForm):
class Meta:
model = Postulation
fields = ('postulant', 'name', 'province', 'city', 'description',
'business_area', 'status', 'progress')
labels = {
'name': 'nombre del proyecto',
'province': 'departamento',
'city': 'ciudad',
'postulant': 'postulante',
'business_area': 'rubro',
'description': 'descripción',
'status': 'estado',
'progress': 'progreso',
}
postulant = AutoCompleteSelectField('entrepreneurs',
label='emprendedores',
help_text='Búsqueda por CI o nombre')
city = AutoCompleteSelectField(
'city',
label="Ciudad",
help_text='Ingresa el nombre de la ciudad o de su departamento',
required=False)
def __init__(self, *args, **kwargs):
super(PostulationForm, self).__init__(*args, **kwargs)
for visible in self.visible_fields():
set_attribute(visible)
class FormVoo(MyModelForm):
def clean(self):
cleaned_data = self.cleaned_data
data_p = cleaned_data.get('data_hora_partida')
cidade_p = cleaned_data.get('cidade_partida')
data_c = cleaned_data.get('data_hora_chegada')
cidade_c = cleaned_data.get('cidade_chegada')
if data_p and data_c and data_p >= data_c:
raise forms.ValidationError(
'Data e hora de partida anterior a data e hora de chegada!')
if cidade_p and cidade_c and cidade_p == cidade_c:
raise forms.ValidationError(
'A cidade de chegada deve ser diferente da cidade de partida!')
return cleaned_data
class Meta:
model = Voo
exclude = []
deputado = AutoCompleteSelectField('deputados',
label='Deputado',
help_text=None)
cidade_partida = AutoCompleteSelectField('cidades',
label='Cidade de partida',
help_text=None)
cidade_chegada = AutoCompleteSelectField('cidades',
label='Cidade de chegada',
help_text=None)
companhia = AutoCompleteSelectField('companhias',
label='Companhia aérea',
help_text=None)
class MergeForm(forms.Form):
user1 = AutoCompleteSelectField("users",
label=_("User that will be kept"),
help_text=None,
required=True)
user2 = AutoCompleteSelectField("users",
label=_("User that will be deleted"),
help_text=None,
required=True)
def __init__(self, *args, **kwargs):
super(PrincipalRoleRelationForm, self).__init__(*args, **kwargs)
self.fields['content'].widget = forms.HiddenInput()
self.fields['user'] = AutoCompleteSelectField('perms_user',
required=False)
self.fields['group'] = AutoCompleteSelectField('perms_group',
required=False)
self.fields['role'].queryset = self.fields['role'].queryset.exclude(
slug=ANONYMOUS_ROLE_SLUG)
class OrphanBuildJobsForm(Form):
""" Allows user to select and link build jobs to one product """
product = AutoCompleteSelectField('product', required=True, label='Product')
# MultipleField is throwing an error at the moment,
# so just allow one at once for the moment
# FIXME
#build_jobs = AutoCompleteSelectMultipleField('orphan_build_job', required=True)
build_jobs = AutoCompleteSelectField('orphan_build_job', required=True, label='Build Job')
class MarketPlaceEnableForm(forms.Form):
company = AutoCompleteSelectField('companies',
required=True,
help_text=None)
site = AutoCompleteSelectField('sites', required=True, help_text=None)
def __init__(self, *args, **kwargs):
super(MarketPlaceEnableForm, self).__init__(*args, **kwargs)
self.fields['company'].help_text = (
'The company to add MarketPlace access to.')
self.fields['site'].help_text = (
'The microsite that purchased jobs will appear on.')
class FormInstituicao(MyModelForm):
class Meta:
model = Instituicao
exclude = []
deputado = AutoCompleteSelectField('deputados',
label='Deputado',
help_text=None)
regional = AutoCompleteSelectField('regionais',
label='Regional',
help_text=None)
cidade = AutoCompleteSelectField('cidades', label='Cidade', help_text=None)
class ProfessorForm(NiceErrorModelForm, ACFieldModelForm):
""" Find or create a Professor. """
# AutoCompleteField would make sense for these fields because it only
# returns the value while AutoCompleteSelectField returns the object.
# This way, Javascript on the front end can autofill the other field based
# on the autocompletion of one field because the whole object is available.
# first argument is ajax channel name, defined in models as LookupChannel.
name = AutoCompleteSelectField('professor_object_by_name', help_text='',
label=mark_safe('Professor\'s name <span class="required-field">(required)</span>'),
# allows creating a new Professor on the fly
required=False)
email = AutoCompleteSelectField('professor_object_by_email', help_text='',
label="Professor's email address",
# allows creating a new Professor on the fly
required=False)
class Meta:
model = Professor
# order the fields
fields = ('name', 'email')
def _clean_distinct_field(self, field, value_required=False, *args, **kwargs):
"""
Check to see if Professor model is found before grabbing the field.
Ensure that if Professor was already found, the new field corresponds.
In theory, Javascript could and should ensure this.
In practice, better safe than incoherent.
"""
oldprof = None
if hasattr(self, 'instance') and self.instance and self.instance.pk:
# Professor was already autocompleted. Save that object.
oldprof = self.instance
# Extract the field value, possibly replacing self.instance
value = self._clean_field(field, *args, **kwargs)
if value_required and not value:
raise ValidationError('This field is required.')
if oldprof and not value:
# This field was not supplied, but another one determined the prof.
# Grab field from prof model object.
value = getattr(oldprof, field)
if oldprof and self.instance != oldprof:
# Two different Professor objects have been found across fields.
raise ValidationError('It looks like two or more different Professors have been autocompleted.')
return value
def clean_name(self, *args, **kwargs):
return self._clean_distinct_field('name', value_required=True, *args, **kwargs)
def clean_email(self, *args, **kwargs):
return self._clean_distinct_field('email', *args, **kwargs)
class ArtistForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
if 'instance' not in kwargs:
kwargs.setdefault('initial',{})
kwargs['initial']['artistid'] = \
(Artist.objects.aggregate(artistid=Max('artistid')).get('artistid', 0) or 0) + 1
super(ArtistForm, self).__init__(*args, **kwargs)
class Meta:
model = Artist
person = AutoCompleteSelectField('person', required=True)
payment_to = AutoCompleteSelectField('person', required=False)
class BaseAssetForm(ModelForm):
class Meta:
model = Asset
fields = (
'niw',
'type',
'model',
'invoice_no',
'order_no',
'request_date',
'delivery_date',
'invoice_date',
'production_use_date',
'provider_order_date',
'price',
'support_price',
'support_period',
'support_type',
'support_void_reporting',
'provider',
'status',
'remarks',
'sn',
'barcode',
'warehouse',
)
widgets = {
'remarks': Textarea(attrs={'rows': 3}),
'support_type': Textarea(attrs={'rows': 5}),
}
model = AutoCompleteSelectField(
LOOKUPS['asset_model'],
required=True,
plugin_options=dict(
add_link='/admin/ralph_assets/assetmodel/add/?name=', ))
warehouse = AutoCompleteSelectField(
LOOKUPS['asset_warehouse'],
required=True,
plugin_options=dict(
add_link='/admin/ralph_assets/warehouse/add/?name=', ))
def __init__(self, *args, **kwargs):
mode = kwargs.get('mode')
if mode:
del kwargs['mode']
super(BaseAssetForm, self).__init__(*args, **kwargs)
if mode == "dc":
self.fields['type'].choices = [(c.id, c.desc)
for c in AssetType.DC.choices]
elif mode == "back_office":
self.fields['type'].choices = [(c.id, c.desc)
for c in AssetType.BO.choices]
class ReleaseElementForm(ModelForm):
release = AutoCompleteSelectField('release')
package = AutoCompleteSelectField('package', label="Package")
application = AutoCompleteSelectField('application', label="Application", required=False)
class Meta:
model = ReleaseElement
def __init__(self, *args, **kwargs):
super(ReleaseElementForm, self).__init__(*args, **kwargs)
instance = getattr(self, 'instance', None)
if instance and instance.id and instance.release.deployment_requests.exists():
force_readonly(self)
class featuresForm(forms.ModelForm):
url = forms.CharField(label='URI',
required=True,
widget=forms.TextInput(attrs={'size': '50'}))
authority_record = AutoCompleteSelectField('authority_record',
required=False)
time_frame = AutoCompleteSelectField('time_frame', required=False)
feature_type = AutoCompleteSelectField('feature_type', required=False)
# exclude = ('info',)
class Meta:
model = Feature
class CompanyFormSet(forms.ModelForm):
local_tax_office = AutoCompleteSelectField('local_tax',
label='地税局',
show_help_text=False,
required=False)
national_tax_office = AutoCompleteSelectField('national_tax',
label='国税局',
show_help_text=False,
required=False)
class Meta:
model = Company
fields = '__all__'
class ApplicantForm(forms.ModelForm):
class Meta:
model = Applicant
widgets = {
'total_income':
NumberInput(attrs={
'style': 'text-align:right;',
'step': .01
}),
'adjusted_available_income':
NumberInput(attrs={
'style': 'text-align:right;',
'step': .01
}),
'calculated_payment':
NumberInput(attrs={
'style': 'text-align:right;',
'step': .01
}),
}
ssn = USSocialSecurityNumberField(required=False, label="SSN")
siblings = AutoCompleteSelectMultipleField('all_student', required=False)
parent_guardians = AutoCompleteSelectMultipleField('emergency_contact',
required=False)
application_decision_by = AutoCompleteSelectField('faculty_user',
required=False)
class AssessmentForm(forms.Form):
target = AutoCompleteSelectField(
'digital_objects-embedded',
required=True,
help_text=None,
)
rubric = AutoCompleteSelectField(
'rubrics-embedded',
required=True,
help_text=None,
)
project = AutoCompleteSelectField(
'projects-embedded',
required=False,
help_text=None,
)
class AllTaxon(forms.Form):
taxon = AutoCompleteSelectField("valid_and_syn",
required=True,
help_text=None)
class Meta:
model = Taxon
class CustomerSenderBlacklistBatchForm(forms.ModelForm):
customer = AutoCompleteSelectField('customer',
required=False,
help_text=None,
label=u'用户/公司',
plugin_options={
'autoFocus': True,
'minLength': 1
})
senders = forms.CharField(label=u'发件人',
widget=forms.Textarea,
required=True,
help_text=u'一行一条记录')
def __init__(self, *args, **kwargs):
super(CustomerSenderBlacklistBatchForm,
self).__init__(*args, **kwargs) # populates the post
self.fields['customer'].queryset = Customer.objects.all().order_by(
'username')
self.fields[
'customer'].label_from_instance = lambda obj: "%s ( %s )" % (
obj.username, obj.company)
def clean_customer(self):
data = self.cleaned_data['customer']
is_global = self.data.get('is_global', False)
if not is_global and not data:
raise forms.ValidationError(u"如果是非全局变量，请添加相应客户")
return data
class Meta:
model = CustomerSenderBlacklist
exclude = ['creater', 'operater', 'operate_time', 'sender']
class ProjectionistForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.form_class = "form-horizontal"
self.helper.form_method = 'post'
self.helper.form_action = ''
self.helper.layout = Layout(
'user',
# 'pit_level',
'license_number',
Field('license_expiry', css_class="datepick"),
FormActions(Submit('save', 'Save Changes'), ))
super(ProjectionistForm, self).__init__(*args, **kwargs)
self.fields['user'].queryset = get_user_model().objects.exclude(
projectionist__isnull=False)
user = AutoCompleteSelectField(
'Users',
required=True,
plugin_options={
'position':
"{ my : \"right top\", at: \"right bottom\", of: \"#id_person_name_text\"},'minlength':4"
})
class Meta:
model = Projectionist
fields = ('user', 'license_number', 'license_expiry')
class SpamRptBlacklistBatchForm(forms.ModelForm):
customer = AutoCompleteSelectField('customer',
required=True,
help_text=None,
label=u'用户/公司',
plugin_options={
'autoFocus': True,
'minLength': 1
})
recipients = forms.CharField(label=u'收件人',
widget=forms.Textarea,
required=True,
help_text=u'一行一条记录')
def __init__(self, *args, **kwargs):
super(SpamRptBlacklistBatchForm,
self).__init__(*args, **kwargs) # populates the post
self.fields['customer'].queryset = Customer.objects.all().order_by(
'username')
self.fields[
'customer'].label_from_instance = lambda obj: "%s ( %s )" % (
obj.username, obj.company)
class Meta:
model = SpamRptBlacklist
exclude = [
'created', 'creater', 'operater', 'operate_time', 'recipient'
]
class PlayerSearchForm(forms.Form): q = AutoCompleteSelectField( 'player', required=True, help_text="help_text", label="label", )
def __new__(cls, name, bases, attrs):
new_attrs = {}
if (hasattr(model_class, 'geo')):
new_attrs['geo'] = FormField(GeoLocationForm, related=True)
if (hasattr(model_class, 'user')):
new_attrs['user'] = AutoCompleteSelectField('user',
required=False)
if (hasattr(model_class, 'avatar')):
new_attrs['avatar'] = FormField(ImageForm,
related=True,
required=False)
opts = model_class._meta
# Avoid circular import
from django.db.models.fields import Field as ModelField
sortable_virtual_fields = [
f for f in opts.virtual_fields if isinstance(f, ModelField)
]
fields = dict(
(f.name, f)
for f in sorted(opts.concrete_fields +
sortable_virtual_fields + opts.many_to_many))
for key, value in new_attrs.items():
value.label = fields[key].verbose_name
value.help_text = fields[key].help_text
value.required = (fields[key].blank == False
and fields[key].null == False)
attrs.update(new_attrs)
return super(BetterMetaClass, cls).__new__(cls, name, bases, attrs)
class OrderForm(forms.ModelForm):
customer = AutoCompleteSelectField('customer', required=False)
def __init__(self, *args, **kwargs):
super(OrderForm, self).__init__(*args, **kwargs)
self.fields['number'].label = "Order/Receipt #"
self.fields['number'].required = True
self.fields['status'].initial='N'
self.fields['status'].required = True
#self.fields['order_date'].widget = BootstrapDateInput()
self.fields['order_date'].widget = DateTimePicker(options=DATEPICKER_OPTIONS)
self.fields['order_date'].label = "Ordered Date"
self.fields['order_date'].widget.attrs['class'] += " order-date"
self.fields['subtotal_after_discount'].required = True
def clean_number(self):
'''
SO number validation: make sure that order
numbers are valid according to specific format
'''
number = self.cleaned_data.get('number')
if not order_utils.is_valid_order_number(number):
raise forms.ValidationError("Order number should be in the following format: %s" % settings.ORDER_FORMAT_DESC)
elif order_utils.is_duplicate_order_exists(number, self.instance):
raise forms.ValidationError("Order with the same number already exists")
return number
class Meta:
model = Order
fields = "__all__"
class ServiceCatalogMixin(forms.ModelForm):
# although it is possible, this mixin shouldn't be instantiated on its own
# (that's why it is still called a mixin, while technically it is a
# subclass of ModelForm and therefore it *can* be instantiated)
# -- just try to think of it as an abstract class, ok? ;)
service = AutoCompleteSelectField(
('ralph.ui.channels', 'ServiceCatalogLookup'),
required=True,
label=_('Service catalog'),
)
device_environment = forms.ModelChoiceField(
required=True,
queryset=DeviceEnvironment.objects.all(),
label=_('Device environment'),
)
def clean_device_environment(self):
device_environment = self.cleaned_data['device_environment']
service = self.cleaned_data['service']
envs_allowed = service.get_environments()
if device_environment not in envs_allowed:
envs_allowed_str = ', '.join([e.name for e in envs_allowed])
if len(envs_allowed) > 0:
msg = (
"This value is not allowed for the service selected. "
"Use one of these instead: {}.".format(envs_allowed_str))
else:
msg = "This value is not allowed for the service selected."
raise forms.ValidationError(msg)
return device_environment