class ContributionForm(forms.ModelForm):
contributor = UserModelChoiceField(
queryset=UserProfile.objects.exclude_inactive_users())
responsibility = forms.ChoiceField(
widget=forms.RadioSelect(),
choices=Contribution.RESPONSIBILITY_CHOICES)
evaluation = forms.ModelChoiceField(Evaluation.objects.all(),
disabled=True,
required=False,
widget=forms.HiddenInput())
questionnaires = forms.ModelMultipleChoiceField(
Questionnaire.objects.contributor_questionnaires().filter(
obsolete=False),
required=False,
widget=CheckboxSelectMultiple,
label=_("Questionnaires"))
does_not_contribute = forms.BooleanField(
required=False, label=_("Does not contribute to evaluation"))
class Meta:
model = Contribution
fields = ('evaluation', 'contributor', 'questionnaires', 'order',
'responsibility', 'textanswer_visibility', 'label')
widgets = {
'order':
forms.HiddenInput(),
'textanswer_visibility':
forms.RadioSelect(
choices=Contribution.TEXTANSWER_VISIBILITY_CHOICES)
}
def __init__(self, *args, evaluation=None, **kwargs):
self.evaluation = evaluation
# work around https://code.djangoproject.com/ticket/25880
if self.evaluation is None:
assert 'instance' in kwargs
self.evaluation = kwargs['instance'].evaluation
super().__init__(*args, **kwargs)
if self.instance.can_edit:
self.fields['responsibility'].initial = Contribution.IS_EDITOR
else:
self.fields['responsibility'].initial = Contribution.IS_CONTRIBUTOR
if self.instance.contributor:
self.fields['contributor'].queryset |= UserProfile.objects.filter(
pk=self.instance.contributor.pk)
self.fields[
'questionnaires'].queryset = Questionnaire.objects.contributor_questionnaires(
).filter(
Q(obsolete=False)
| Q(contributions__evaluation=self.evaluation)).distinct()
if self.instance.pk:
self.fields[
'does_not_contribute'].initial = not self.instance.questionnaires.exists(
)
if self.evaluation.pk and not self.evaluation.can_be_edited_by_manager:
# form is used as read-only evaluation view
disable_all_fields(self)
def clean(self):
if not self.cleaned_data.get(
'does_not_contribute') and not self.cleaned_data.get(
'questionnaires'):
self.add_error(
'does_not_contribute',
_("Select either this option or at least one questionnaire!"))
def save(self, *args, **kwargs):
responsibility = self.cleaned_data['responsibility']
is_editor = responsibility == Contribution.IS_EDITOR
self.instance.can_edit = is_editor
return super().save(*args, **kwargs)
class CompanyRegisterForm(forms.Form):
# FIELDS EMPRESA
razaosocial = forms.CharField(label='Razão Social:', max_length=100)
nomefantasia = forms.CharField(label='Nome Fantasia:', max_length=100)
cnpj = forms.CharField(label='CNPJ:', max_length=20)
ie = forms.CharField(label='Inscrição Estadual', max_length=45)
tipo_empresa = forms.ModelChoiceField(TipoEmpresa,
label='Tipo de Empresa:',
widget=forms.Select())
# FIELDS LOGRADOURO
cep = forms.CharField(label='CEP:', max_length=10)
rua = forms.CharField(label='Rua:', max_length=100)
bairro = forms.CharField(label='Bairro:', max_length=45)
cidade = forms.CharField(label='Cidade:', max_length=20)
estado = forms.CharField(label='Estado:', max_length=2)
pais = forms.CharField(label='País:', max_length=45)
# FIELDS ENDERECO
numeroed = forms.IntegerField(label='Numero:')
complemento = forms.CharField(label='Complemento:', max_length=45)
pontoreferencia = forms.CharField(label='Ponto de referência:',
max_length=45,
widget=forms.Textarea)
def __init__(self, *args, **kwargs):
super(CompanyRegisterForm, self).__init__(*args, **kwargs)
'''
FIELDS EMPRESA
'''
# Razaosocial Fields widget
self.fields['razaosocial'].widget.attrs['class'] = 'form-control'
self.fields['razaosocial'].widget.attrs[
'placeholder'] = 'Digite a Razão Social'
# Nomefantasia Fields widget
self.fields['nomefantasia'].widget.attrs['class'] = 'form-control'
self.fields['nomefantasia'].widget.attrs[
'placeholder'] = 'Digite o Nome Fantasia'
# Cnpj Fields widget
self.fields['cnpj'].widget.attrs['class'] = 'form-control'
self.fields['cnpj'].widget.attrs[
'onblur'] = 'get_cnpj_data(this.value)'
self.fields['cnpj'].widget.attrs[
'placeholder'] = 'Digite a Razão Social'
# Ie Fields widget
self.fields['ie'].widget.attrs['class'] = 'form-control'
self.fields['ie'].widget.attrs['placeholder'] = 'Inscrição Estadual'
# Tipo_empresa Fields widget
self.fields['tipo_empresa'].widget.attrs['class'] = 'form-control'
self.fields['tipo_empresa'].queryset = TipoEmpresa.objects.all()
'''
FIELDS LOGRADOURO
'''
# CEP Fields widget
self.fields['cep'].widget.attrs['class'] = 'form-control'
self.fields['cep'].widget.attrs['onblur'] = 'get_cep_data(this.value)'
self.fields['cep'].widget.attrs['placeholder'] = 'Digite o CEP'
# Rua Fields widget
self.fields['rua'].widget.attrs['class'] = 'form-control'
self.fields['rua'].widget.attrs['placeholder'] = 'Digite a rua'
# Bairro Fields widget
self.fields['bairro'].widget.attrs['class'] = 'form-control'
self.fields['bairro'].widget.attrs['placeholder'] = 'Digite o bairro'
# Cidade Fields widget
self.fields['cidade'].widget.attrs['class'] = 'form-control'
self.fields['cidade'].widget.attrs['placeholder'] = 'Digite a cidade'
# Estado Fields widget
self.fields['estado'].widget.attrs['class'] = 'form-control'
self.fields['estado'].widget.attrs['placeholder'] = 'Digite o estado'
# Pais Fields widget
self.fields['pais'].widget.attrs['class'] = 'form-control'
self.fields['pais'].widget.attrs['placeholder'] = 'Digite o pais'
'''
FIELDS ENDERECO
'''
# Numero Fields widget
self.fields['numeroed'].widget.attrs['class'] = 'form-control'
self.fields['numeroed'].widget.attrs['placeholder'] = 'Digite o numero'
# Complemento Fields widget
self.fields['complemento'].widget.attrs['class'] = 'form-control'
self.fields['complemento'].widget.attrs[
'placeholder'] = 'Digite o complemento'
# Pontoreferencia Fields widget
self.fields['pontoreferencia'].widget.attrs['class'] = 'form-control'
self.fields['pontoreferencia'].widget.attrs[
'placeholder'] = 'Digite um ponto de referência'
pass
class options_form(forms.Form):
job = forms.ModelChoiceField(queryset=CodingJob.objects.all())
class NotificationForm(forms.Form):
scope = forms.ChoiceField(choices=SCOPE_CHOICES,
widget=forms.HiddenInput,
required=True)
project = forms.ModelChoiceField(widget=forms.HiddenInput,
queryset=Project.objects.none(),
required=False)
component = forms.ModelChoiceField(widget=forms.HiddenInput,
queryset=Component.objects.none(),
required=False)
def __init__(self, user, show_default, subscriptions, is_active, *args,
**kwargs):
super().__init__(*args, **kwargs)
self.user = user
self.is_active = is_active
self.show_default = show_default
self.fields["project"].queryset = user.allowed_projects
self.fields["component"].queryset = Component.objects.filter_access(
user)
language_fields = []
component_fields = []
for field, notification_cls in self.notification_fields():
self.fields[field] = forms.ChoiceField(
label=notification_cls.verbose,
choices=self.get_choices(notification_cls, show_default),
required=True,
initial=self.get_initial(notification_cls, subscriptions,
show_default),
)
if notification_cls.filter_languages:
language_fields.append(field)
else:
component_fields.append(field)
self.helper = FormHelper(self)
self.helper.disable_csrf = True
self.helper.form_tag = False
self.helper.label_class = "col-md-3"
self.helper.field_class = "col-md-9"
self.helper.layout = Layout(
"scope",
"project",
"component",
Fieldset(
_("Component wide notifications"),
HTML(escape(self.get_help_component())),
*component_fields,
),
Fieldset(
_("Translation notifications"),
HTML(escape(self.get_help_translation())),
*language_fields,
),
)
@staticmethod
def notification_fields():
for notification_cls in NOTIFICATIONS:
yield (f"notify-{notification_cls.get_name()}", notification_cls)
@staticmethod
def get_initial(notification_cls, subscriptions, show_default):
return subscriptions.get(notification_cls.get_name(),
-1 if show_default else 0)
@staticmethod
def get_choices(notification_cls, show_default):
result = []
if show_default:
result.append((-1, _("Use default setting")))
result.extend(notification_cls.get_freq_choices())
return result
@cached_property
def form_params(self):
if self.is_bound:
self.is_valid()
return self.cleaned_data
return self.initial
@cached_property
def form_scope(self):
return self.form_params.get("scope", SCOPE_WATCHED)
@cached_property
def form_project(self):
return self.form_params.get("project", None)
@cached_property
def form_component(self):
return self.form_params.get("component", None)
def get_name(self):
scope = self.form_scope
if scope == SCOPE_ALL:
return _("Other projects")
if scope == SCOPE_WATCHED:
return _("Watched projects")
if scope == SCOPE_ADMIN:
return _("Managed projects")
if scope == SCOPE_PROJECT:
return _("Project: {}").format(self.form_project)
return _("Component: {}").format(self.form_component)
def get_help_component(self):
scope = self.form_scope
if scope == SCOPE_ALL:
return _("You will receive a notification for every such event"
" in non-watched projects.")
if scope == SCOPE_WATCHED:
return _("You will receive a notification for every such event"
" in your watched projects.")
if scope == SCOPE_ADMIN:
return _("You will receive a notification for every such event"
" in projects where you have admin permissions.")
if scope == SCOPE_PROJECT:
return _(
"You will receive a notification for every such event in %(project)s."
) % {
"project": self.form_project
}
return _(
"You will receive a notification for every such event in %(component)s."
) % {
"component": self.form_component
}
def get_help_translation(self):
scope = self.form_scope
if scope == SCOPE_ALL:
return _(
"You will only receive these notifications for your translated "
"languages in non-watched projects.")
if scope == SCOPE_WATCHED:
return _(
"You will only receive these notifications for your translated "
"languages in your watched projects.")
if scope == SCOPE_ADMIN:
return _(
"You will only receive these notifications for your translated "
"languages in projects where you have admin permissions.")
if scope == SCOPE_PROJECT:
return _("You will only receive these notifications for your"
" translated languages in %(project)s.") % {
"project": self.form_project
}
return _("You will only receive these notifications for your"
" translated languages in %(component)s.") % {
"component": self.form_component
}
def save(self):
# Lookup for this form
lookup = {
"scope": self.cleaned_data["scope"],
"project": self.cleaned_data["project"],
"component": self.cleaned_data["component"],
}
handled = set()
for field, notification_cls in self.notification_fields():
frequency = self.cleaned_data[field]
# We do not store defaults or disabled default subscriptions
if frequency == "-1" or (frequency == "0"
and not self.show_default):
continue
# Create/Get from database
subscription, created = self.user.subscription_set.get_or_create(
notification=notification_cls.get_name(),
defaults={"frequency": frequency},
**lookup,
)
# Update old subscription
if not created and subscription.frequency != frequency:
subscription.frequency = frequency
subscription.save(update_fields=["frequency"])
handled.add(subscription.pk)
# Delete stale subscriptions
self.user.subscription_set.filter(**lookup).exclude(
pk__in=handled).delete()
class ImportForm(forms.Form):
def clean(self):
# If there are validation errors earlier on, don't bother.
if not ('address_file' in self.cleaned_data and
'ignore_errors' in self.cleaned_data and
'newsletter' in self.cleaned_data):
return self.cleaned_data
# TESTME: Should an error be raised here or not?
# raise forms.ValidationError(_("No file has been specified."))
ignore_errors = self.cleaned_data['ignore_errors']
newsletter = self.cleaned_data['newsletter']
myfield = self.base_fields['address_file']
myvalue = myfield.widget.value_from_datadict(
self.data, self.files, self.add_prefix('address_file'))
content_type = myvalue.content_type
allowed_types = ('text/plain', 'application/octet-stream',
'text/vcard', 'text/directory', 'text/x-vcard',
'application/vnd.ms-excel',
'text/comma-separated-values', 'text/csv',
'application/csv', 'application/excel',
'application/vnd.msexcel', 'text/anytext')
if content_type not in allowed_types:
raise forms.ValidationError(_(
"File type '%s' was not recognized.") % content_type)
self.addresses = []
ext = myvalue.name.rsplit('.', 1)[-1].lower()
if ext == 'vcf':
self.addresses = parse_vcard(
myvalue.file, newsletter, ignore_errors)
elif ext == 'ldif':
self.addresses = parse_ldif(
myvalue.file, newsletter, ignore_errors)
elif ext == 'csv':
self.addresses = parse_csv(
myvalue.file, newsletter, ignore_errors)
print(self.addresses)
else:
raise forms.ValidationError(
_("File extention '%s' was not recognized.") % ext)
if len(self.addresses) == 0:
raise forms.ValidationError(
_("No entries could found in this file."))
print('cleaned data')
print(self.cleaned_data)
return self.cleaned_data
def get_addresses(self):
if hasattr(self, 'addresses'):
# print('el objeto tiene atributo addresses')
logger.debug('Getting addresses: %s', self.addresses)
# print(self.addresses)
return self.addresses
else:
return {}
newsletter = forms.ModelChoiceField(
label=_("Newsletter"),
queryset=Newsletter.objects.all(),
initial=Newsletter.get_default_id())
address_file = forms.FileField(label=_("Address file"))
ignore_errors = forms.BooleanField(
label=_("Ignore non-fatal errors"),
initial=True, required=False)
class InvestigationForm(forms.Form):
investigation = forms.ModelChoiceField(queryset=Investigation.objects.all(), required=True, help_text="Note: Investigations contain: individual investigations, missions, observing campaigns, or other investigations</br>")
class DatabaseForm(models.ModelForm):
plan = AdvancedModelChoiceField(
queryset=Plan.objects.filter(is_active='True'),
required=False,
widget=forms.RadioSelect,
empty_label=None)
engine = forms.ModelChoiceField(queryset=Engine.objects)
environment = forms.ModelChoiceField(queryset=Environment.objects)
class Meta:
model = Database
fields = (
'name',
'description',
'project',
'team',
'is_in_quarantine',
)
def remove_fields_not_in_models(self):
"""remove fields not int models"""
fields_to_remove = ["plan", "engine", "environment"]
for field_name in fields_to_remove:
if field_name in self.fields:
del self.fields[field_name]
@classmethod
def setup_offering_field(cls, form, db_instance):
form.declared_fields['offering'] = forms.CharField(
widget=DatabaseOfferingWidget(attrs={
'readonly': 'readonly',
'database': db_instance
}),
required=False,
initial=db_instance.offering)
def __init__(self, *args, **kwargs):
super(DatabaseForm, self).__init__(*args, **kwargs)
instance = kwargs.get('instance')
if instance:
LOG.debug("instance database form found! %s" % instance)
#remove fields not in models
self.remove_fields_not_in_models()
else:
self.fields['is_in_quarantine'].widget = forms.HiddenInput()
def clean(self):
cleaned_data = super(DatabaseForm, self).clean()
# if there is an instance, that means that we are in a edit page and therefore
# it should return the default cleaned_data
if self.instance and self.instance.id:
return cleaned_data
# TODO: change model field to blank=False
if 'team' in cleaned_data:
team = cleaned_data['team']
LOG.debug("team: %s" % team)
if not team:
LOG.warning("No team specified in database form")
self._errors["team"] = self.error_class(
[_("Team: This field is required.")])
if not self.is_valid():
raise forms.ValidationError(self.errors)
if len(cleaned_data['name']) > 40:
self._errors["name"] = self.error_class(
[_("Database name too long")])
if 'plan' in cleaned_data:
plan = cleaned_data.get('plan', None)
if not plan:
self._errors["plan"] = self.error_class(
[_("Plan: This field is required.")])
if 'project' in cleaned_data:
project = cleaned_data.get('project', None)
if not project:
self._errors["project"] = self.error_class(
[_("Project: This field is required.")])
if 'description' in cleaned_data:
description = cleaned_data.get('description', None)
if not description:
self._errors["description"] = self.error_class(
[_("Description: This field is required.")])
if 'environment' in cleaned_data:
environment = cleaned_data.get('environment', None)
if not environment or environment not in plan.environments.all():
raise forms.ValidationError(
_("Invalid plan for selected environment."))
#validate if the team has available resources
dbs = team.databases_in_use_for(environment)
database_alocation_limit = team.database_alocation_limit
LOG.debug("dbs: %s | type: %s" % (dbs, type(dbs)))
if (database_alocation_limit != 0
and len(dbs) >= database_alocation_limit):
LOG.warning(
"The database alocation limit of %s has been exceeded for the selected team %s => %s"
% (database_alocation_limit, team, list(dbs)))
self._errors["team"] = self.error_class([
_("The database alocation limit of %s has been exceeded for the selected team: %s"
) % (database_alocation_limit, list(dbs))
])
#for infra in DatabaseInfra.objects.filter(environment=environment,):
# if infra.databases.filter(name=cleaned_data['name']):
# self._errors["name"] = self.error_class([_("this name already exists in the selected environment")])
driver = DriverFactory.get_driver_class(plan.engines[0].name)
if 'name' in cleaned_data and cleaned_data[
'name'] in driver.RESERVED_DATABASES_NAME:
raise forms.ValidationError(
_("%s is a reserved database name" % cleaned_data['name']))
if self._errors:
return cleaned_data
return cleaned_data
def save_m2m(self, *args, **kwargs):
pass
class PrefixCSVForm(forms.ModelForm):
vrf = FlexibleModelChoiceField(
queryset=VRF.objects.all(),
to_field_name='rd',
required=False,
help_text='Route distinguisher of parent VRF (or {ID})',
error_messages={
'invalid_choice': 'VRF not found.',
}
)
tenant = forms.ModelChoiceField(
queryset=Tenant.objects.all(),
required=False,
to_field_name='name',
help_text='Name of assigned tenant',
error_messages={
'invalid_choice': 'Tenant not found.',
}
)
site = forms.ModelChoiceField(
queryset=Site.objects.all(),
required=False,
to_field_name='name',
help_text='Name of parent site',
error_messages={
'invalid_choice': 'Site not found.',
}
)
vlan_group = forms.CharField(
help_text='Group name of assigned VLAN',
required=False
)
vlan_vid = forms.IntegerField(
help_text='Numeric ID of assigned VLAN',
required=False
)
status = CSVChoiceField(
choices=PrefixStatusChoices,
help_text='Operational status'
)
role = forms.ModelChoiceField(
queryset=Role.objects.all(),
required=False,
to_field_name='name',
help_text='Functional role',
error_messages={
'invalid_choice': 'Invalid role.',
}
)
class Meta:
model = Prefix
fields = Prefix.csv_headers
def clean(self):
super().clean()
site = self.cleaned_data.get('site')
vlan_group = self.cleaned_data.get('vlan_group')
vlan_vid = self.cleaned_data.get('vlan_vid')
# Validate VLAN
if vlan_group and vlan_vid:
try:
self.instance.vlan = VLAN.objects.get(site=site, group__name=vlan_group, vid=vlan_vid)
except VLAN.DoesNotExist:
if site:
raise forms.ValidationError("VLAN {} not found in site {} group {}".format(
vlan_vid, site, vlan_group
))
else:
raise forms.ValidationError("Global VLAN {} not found in group {}".format(vlan_vid, vlan_group))
except MultipleObjectsReturned:
raise forms.ValidationError(
"Multiple VLANs with VID {} found in group {}".format(vlan_vid, vlan_group)
)
elif vlan_vid:
try:
self.instance.vlan = VLAN.objects.get(site=site, group__isnull=True, vid=vlan_vid)
except VLAN.DoesNotExist:
if site:
raise forms.ValidationError("VLAN {} not found in site {}".format(vlan_vid, site))
else:
raise forms.ValidationError("Global VLAN {} not found".format(vlan_vid))
except MultipleObjectsReturned:
raise forms.ValidationError("Multiple VLANs with VID {} found".format(vlan_vid))
class IPAddressForm(BootstrapMixin, TenancyForm, ReturnURLForm, CustomFieldForm):
interface = forms.ModelChoiceField(
queryset=Interface.objects.all(),
required=False
)
nat_site = forms.ModelChoiceField(
queryset=Site.objects.all(),
required=False,
label='Site',
widget=APISelect(
api_url="/api/dcim/sites/",
filter_for={
'nat_rack': 'site_id',
'nat_device': 'site_id'
}
)
)
nat_rack = ChainedModelChoiceField(
queryset=Rack.objects.all(),
chains=(
('site', 'nat_site'),
),
required=False,
label='Rack',
widget=APISelect(
api_url='/api/dcim/racks/',
display_field='display_name',
filter_for={
'nat_device': 'rack_id'
},
attrs={
'nullable': 'true'
}
)
)
nat_device = ChainedModelChoiceField(
queryset=Device.objects.all(),
chains=(
('site', 'nat_site'),
('rack', 'nat_rack'),
),
required=False,
label='Device',
widget=APISelect(
api_url='/api/dcim/devices/',
display_field='display_name',
filter_for={
'nat_inside': 'device_id'
}
)
)
nat_inside = ChainedModelChoiceField(
queryset=IPAddress.objects.all(),
chains=(
('interface__device', 'nat_device'),
),
required=False,
label='IP Address',
widget=APISelect(
api_url='/api/ipam/ip-addresses/',
display_field='address'
)
)
primary_for_parent = forms.BooleanField(
required=False,
label='Make this the primary IP for the device/VM'
)
tags = TagField(
required=False
)
class Meta:
model = IPAddress
fields = [
'address', 'vrf', 'status', 'role', 'dns_name', 'description', 'interface', 'primary_for_parent',
'nat_site', 'nat_rack', 'nat_inside', 'tenant_group', 'tenant', 'tags',
]
widgets = {
'status': StaticSelect2(),
'role': StaticSelect2(),
'vrf': APISelect(
api_url="/api/ipam/vrfs/"
)
}
def __init__(self, *args, **kwargs):
# Initialize helper selectors
instance = kwargs.get('instance')
initial = kwargs.get('initial', {}).copy()
if instance and instance.nat_inside and instance.nat_inside.device is not None:
initial['nat_site'] = instance.nat_inside.device.site
initial['nat_rack'] = instance.nat_inside.device.rack
initial['nat_device'] = instance.nat_inside.device
kwargs['initial'] = initial
super().__init__(*args, **kwargs)
self.fields['vrf'].empty_label = 'Global'
# Limit interface selections to those belonging to the parent device/VM
if self.instance and self.instance.interface:
self.fields['interface'].queryset = Interface.objects.filter(
device=self.instance.interface.device, virtual_machine=self.instance.interface.virtual_machine
)
else:
self.fields['interface'].choices = []
# Initialize primary_for_parent if IP address is already assigned
if self.instance.pk and self.instance.interface is not None:
parent = self.instance.interface.parent
if (
self.instance.address.version == 4 and parent.primary_ip4_id == self.instance.pk or
self.instance.address.version == 6 and parent.primary_ip6_id == self.instance.pk
):
self.initial['primary_for_parent'] = True
def clean(self):
super().clean()
# Primary IP assignment is only available if an interface has been assigned.
if self.cleaned_data.get('primary_for_parent') and not self.cleaned_data.get('interface'):
self.add_error(
'primary_for_parent', "Only IP addresses assigned to an interface can be designated as primary IPs."
)
def save(self, *args, **kwargs):
ipaddress = super().save(*args, **kwargs)
# Assign/clear this IPAddress as the primary for the associated Device/VirtualMachine.
if self.cleaned_data['primary_for_parent']:
parent = self.cleaned_data['interface'].parent
if ipaddress.address.version == 4:
parent.primary_ip4 = ipaddress
else:
parent.primary_ip6 = ipaddress
parent.save()
elif self.cleaned_data['interface']:
parent = self.cleaned_data['interface'].parent
if ipaddress.address.version == 4 and parent.primary_ip4 == ipaddress:
parent.primary_ip4 = None
parent.save()
elif ipaddress.address.version == 6 and parent.primary_ip6 == ipaddress:
parent.primary_ip6 = None
parent.save()
return ipaddress
class VLANCSVForm(forms.ModelForm):
site = forms.ModelChoiceField(
queryset=Site.objects.all(),
required=False,
to_field_name='name',
help_text='Name of parent site',
error_messages={
'invalid_choice': 'Site not found.',
}
)
group_name = forms.CharField(
help_text='Name of VLAN group',
required=False
)
tenant = forms.ModelChoiceField(
queryset=Tenant.objects.all(),
to_field_name='name',
required=False,
help_text='Name of assigned tenant',
error_messages={
'invalid_choice': 'Tenant not found.',
}
)
status = CSVChoiceField(
choices=VLANStatusChoices,
help_text='Operational status'
)
role = forms.ModelChoiceField(
queryset=Role.objects.all(),
required=False,
to_field_name='name',
help_text='Functional role',
error_messages={
'invalid_choice': 'Invalid role.',
}
)
class Meta:
model = VLAN
fields = VLAN.csv_headers
help_texts = {
'vid': 'Numeric VLAN ID (1-4095)',
'name': 'VLAN name',
}
def clean(self):
super().clean()
site = self.cleaned_data.get('site')
group_name = self.cleaned_data.get('group_name')
# Validate VLAN group
if group_name:
try:
self.instance.group = VLANGroup.objects.get(site=site, name=group_name)
except VLANGroup.DoesNotExist:
if site:
raise forms.ValidationError(
"VLAN group {} not found for site {}".format(group_name, site)
)
else:
raise forms.ValidationError(
"Global VLAN group {} not found".format(group_name)
)
class PrefixForm(BootstrapMixin, TenancyForm, CustomFieldForm):
site = forms.ModelChoiceField(
queryset=Site.objects.all(),
required=False,
label='Site',
widget=APISelect(
api_url="/api/dcim/sites/",
filter_for={
'vlan_group': 'site_id',
'vlan': 'site_id',
},
attrs={
'nullable': 'true',
}
)
)
vlan_group = ChainedModelChoiceField(
queryset=VLANGroup.objects.all(),
chains=(
('site', 'site'),
),
required=False,
label='VLAN group',
widget=APISelect(
api_url='/api/ipam/vlan-groups/',
filter_for={
'vlan': 'group_id'
},
attrs={
'nullable': 'true',
}
)
)
vlan = ChainedModelChoiceField(
queryset=VLAN.objects.all(),
chains=(
('site', 'site'),
('group', 'vlan_group'),
),
required=False,
label='VLAN',
widget=APISelect(
api_url='/api/ipam/vlans/',
display_field='display_name'
)
)
tags = TagField(required=False)
class Meta:
model = Prefix
fields = [
'prefix', 'vrf', 'site', 'vlan', 'status', 'role', 'is_pool', 'description', 'tenant_group', 'tenant',
'tags',
]
widgets = {
'vrf': APISelect(
api_url="/api/ipam/vrfs/"
),
'status': StaticSelect2(),
'role': APISelect(
api_url="/api/ipam/roles/"
)
}
def __init__(self, *args, **kwargs):
# Initialize helper selectors
instance = kwargs.get('instance')
initial = kwargs.get('initial', {}).copy()
if instance and instance.vlan is not None:
initial['vlan_group'] = instance.vlan.group
kwargs['initial'] = initial
super().__init__(*args, **kwargs)
self.fields['vrf'].empty_label = 'Global'
class SalesmanActivateForm(forms.Form):
salesman = forms.ModelChoiceField(
queryset=Salesman.objects.filter(user__is_active=False),
empty_label=None,
required=True)
class NewMedicineForm(ModelForm): vendor = forms.ModelChoiceField(queryset=Vendor.objects.all(), initial=0) class Meta: model = Medicine fields = ['trade_name','generic_name','description','purchasePrice','unit_selling','threshold_value','vendor']
class NewJobForm(forms.Form):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
clients = Contact.objects.filter(contact_type='client')
staff = Staff.objects.all()
vehicles = Vehicle.objects.all()
self.fields['client'].queryset = clients
self.fields['assigned'].queryset = staff
self.fields['vehicle'].queryset = vehicles
if 'client' in self.data:
try:
owner_id = int(self.data.get('client'))
self.fields['vehicle'].queryset = Contact.objects.get(
owner_id).vehicle_set.all()
except (ValueError, TypeError):
pass # invalid input; fallback to empty Vehicle queryset
select_attrs = {'class': 'form-control'}
input_attrs = {'class': 'form-control'}
date_attrs = {
'class': 'form-control',
'type': 'date',
'placeholder': 'dd/mm/yyyy'
}
job_status_choices = (('pending', 'Pending (Estimate)'),
('confirmed', 'Confirmed (Estimate)'),
('in_progress', 'In progress'), ('done', 'Done'))
payment_method_choices = (('cash', 'Cash'), ('card', 'Card'), ('mpesa',
'M-Pesa'))
client = forms.ModelChoiceField(queryset=None,
widget=forms.Select(attrs=select_attrs))
vehicle = forms.ModelChoiceField(queryset=None,
widget=forms.Select(attrs=select_attrs))
due_start_date = forms.DateField(widget=forms.DateInput(attrs=date_attrs),
required=False)
due_end_date = forms.DateField(widget=forms.DateInput(attrs=date_attrs),
required=False)
description = forms.CharField(widget=forms.Textarea(attrs={
**input_attrs,
**{
'rows': 3
}
}),
required=False)
assigned = forms.ModelChoiceField(required=False,
queryset=None,
widget=forms.Select(attrs=select_attrs))
charged = forms.CharField(widget=forms.NumberInput(attrs={
**input_attrs,
**{
'value': 0
}
}),
required=False)
status = forms.ChoiceField(choices=job_status_choices,
widget=forms.Select(attrs=select_attrs))
payment_method = forms.ChoiceField(choices=payment_method_choices,
widget=forms.Select(attrs=select_attrs))
def clean(self):
start_date = self.cleaned_data.get('due_start_date')
end_date = self.cleaned_data.get('due_end_date')
if not (start_date and end_date):
return self.cleaned_data
if start_date > end_date:
raise forms.ValidationError(
'Due start date can not be later than due end date.')
class TelescopeForm(forms.Form):
telescope = forms.ModelChoiceField(queryset=Telescope.objects.all(), required=True)
class IPAddressCSVForm(forms.ModelForm):
vrf = FlexibleModelChoiceField(
queryset=VRF.objects.all(),
to_field_name='rd',
required=False,
help_text='Route distinguisher of parent VRF (or {ID})',
error_messages={
'invalid_choice': 'VRF not found.',
}
)
tenant = forms.ModelChoiceField(
queryset=Tenant.objects.all(),
to_field_name='name',
required=False,
help_text='Name of the assigned tenant',
error_messages={
'invalid_choice': 'Tenant not found.',
}
)
status = CSVChoiceField(
choices=IPAddressStatusChoices,
help_text='Operational status'
)
role = CSVChoiceField(
choices=IPAddressRoleChoices,
required=False,
help_text='Functional role'
)
device = FlexibleModelChoiceField(
queryset=Device.objects.all(),
required=False,
to_field_name='name',
help_text='Name or ID of assigned device',
error_messages={
'invalid_choice': 'Device not found.',
}
)
virtual_machine = forms.ModelChoiceField(
queryset=VirtualMachine.objects.all(),
required=False,
to_field_name='name',
help_text='Name of assigned virtual machine',
error_messages={
'invalid_choice': 'Virtual machine not found.',
}
)
interface_name = forms.CharField(
help_text='Name of assigned interface',
required=False
)
is_primary = forms.BooleanField(
help_text='Make this the primary IP for the assigned device',
required=False
)
class Meta:
model = IPAddress
fields = IPAddress.csv_headers
def clean(self):
super().clean()
device = self.cleaned_data.get('device')
virtual_machine = self.cleaned_data.get('virtual_machine')
interface_name = self.cleaned_data.get('interface_name')
is_primary = self.cleaned_data.get('is_primary')
# Validate interface
if interface_name and device:
try:
self.instance.interface = Interface.objects.get(device=device, name=interface_name)
except Interface.DoesNotExist:
raise forms.ValidationError("Invalid interface {} for device {}".format(
interface_name, device
))
elif interface_name and virtual_machine:
try:
self.instance.interface = Interface.objects.get(virtual_machine=virtual_machine, name=interface_name)
except Interface.DoesNotExist:
raise forms.ValidationError("Invalid interface {} for virtual machine {}".format(
interface_name, virtual_machine
))
elif interface_name:
raise forms.ValidationError("Interface given ({}) but parent device/virtual machine not specified".format(
interface_name
))
elif device:
raise forms.ValidationError("Device specified ({}) but interface missing".format(device))
elif virtual_machine:
raise forms.ValidationError("Virtual machine specified ({}) but interface missing".format(virtual_machine))
# Validate is_primary
if is_primary and not device and not virtual_machine:
raise forms.ValidationError("No device or virtual machine specified; cannot set as primary IP")
def save(self, *args, **kwargs):
# Set interface
if self.cleaned_data['device'] and self.cleaned_data['interface_name']:
self.instance.interface = Interface.objects.get(
device=self.cleaned_data['device'],
name=self.cleaned_data['interface_name']
)
elif self.cleaned_data['virtual_machine'] and self.cleaned_data['interface_name']:
self.instance.interface = Interface.objects.get(
virtual_machine=self.cleaned_data['virtual_machine'],
name=self.cleaned_data['interface_name']
)
ipaddress = super().save(*args, **kwargs)
# Set as primary for device/VM
if self.cleaned_data['is_primary']:
parent = self.cleaned_data['device'] or self.cleaned_data['virtual_machine']
if self.instance.address.version == 4:
parent.primary_ip4 = ipaddress
elif self.instance.address.version == 6:
parent.primary_ip6 = ipaddress
parent.save()
return ipaddress
def __init__(self, *args, **kwargs):
self.pk_fac = kwargs.pop('pk_fac')
super(FacilityInstrumentForm,self).__init__(*args, **kwargs)
self.fields['instrument'] = forms.ModelChoiceField(queryset=Instrument.objects.filter(facility=self.pk_fac), required=True)
class FiltroDepoimentoForm(forms.Form):
tipo = forms.ModelChoiceField(TipoDepoimentos.objects.all(),
required=False)
def __init__(self, *args, **kwargs):
self.pk_ins = kwargs.pop('pk_ins')
super(InstrumentForm,self).__init__(*args, **kwargs)
self.fields['instrument'] = forms.ModelChoiceField(queryset=Instrument.objects.filter(instrument_host=self.pk_ins), required=True)
def __init__(self, *args, **kwargs):
self.event = kwargs['event']
self.user = kwargs.pop('user')
super().__init__(*args, **kwargs)
self.fields['category'].queryset = self.instance.event.categories.all()
self.fields['category'].widget = Select2(
attrs={
'data-model-select2':
'generic',
'data-select2-url':
reverse('control:event.items.categories.select2',
kwargs={
'event': self.instance.event.slug,
'organizer': self.instance.event.organizer.slug,
}),
'data-placeholder':
_('No category'),
})
self.fields['category'].widget.choices = self.fields[
'category'].choices
self.fields['tax_rule'].queryset = self.instance.event.tax_rules.all()
change_decimal_field(self.fields['default_price'],
self.instance.event.currency)
self.fields['tax_rule'].empty_label = _('No taxation')
self.fields['copy_from'] = forms.ModelChoiceField(
label=_("Copy product information"),
queryset=self.event.items.all(),
widget=forms.Select,
empty_label=_('Do not copy'),
required=False)
if self.event.tax_rules.exists():
self.fields['tax_rule'].required = True
if not self.event.has_subevents:
choices = [(self.NONE, _("Do not add to a quota now")),
(self.EXISTING, _("Add product to an existing quota")),
(self.NEW, _("Create a new quota for this product"))]
if not self.event.quotas.exists():
choices.remove(choices[1])
self.fields['quota_option'] = forms.ChoiceField(
label=_("Quota options"),
widget=forms.RadioSelect,
choices=choices,
initial=self.NONE,
required=False)
self.fields['quota_add_existing'] = forms.ModelChoiceField(
label=_("Add to existing quota"),
widget=forms.Select(),
queryset=self.instance.event.quotas.all(),
required=False)
self.fields['quota_add_new_name'] = forms.CharField(
label=_("Name"),
max_length=200,
widget=forms.TextInput(
attrs={'placeholder': _("New quota name")}),
required=False)
self.fields['quota_add_new_size'] = forms.IntegerField(
min_value=0,
label=_("Size"),
widget=forms.TextInput(
attrs={'placeholder': _("Number of tickets")}),
help_text=_("Leave empty for an unlimited number of tickets."),
required=False)
class CloneDatabaseForm(forms.Form):
database_clone = forms.CharField(label=u'Destination database',
max_length=64,
required=True)
environment = forms.ModelChoiceField(
queryset=Environment.objects,
widget=forms.Select(attrs={'class': 'environment'}),
required='True',
)
engine = forms.CharField(widget=forms.HiddenInput(), )
origin_database_id = forms.CharField(widget=forms.HiddenInput())
old_plan = forms.CharField(widget=forms.HiddenInput())
def __init__(self, *args, **kwargs):
super(CloneDatabaseForm, self).__init__(*args, **kwargs)
if 'initial' in kwargs:
instance = Database.objects.get(
id=kwargs['initial']['origin_database_id'])
elif 'origin_database_id' in self.data:
instance = Database.objects.get(id=self.data['origin_database_id'])
if instance:
LOG.debug("instance database form found! %s" % instance)
self.define_engine_field(database=instance)
self.define_available_plans(database=instance)
self.initial['old_plan'] = instance.plan.id
def define_engine_field(self, database):
self.initial['engine'] = database.infra.engine.engine_type.id
def define_available_plans(self, database):
self.fields['plan'] = forms.ModelChoiceField(
queryset=Plan.objects.filter(
engine_type__name=database.infra.engine.name, is_active=True),
widget=forms.Select(attrs={'class': 'plan'}),
required=True,
)
def clean(self):
cleaned_data = super(CloneDatabaseForm, self).clean()
if 'database_clone' in cleaned_data:
origindatabase = Database.objects.get(
pk=cleaned_data['origin_database_id'])
#for infra in DatabaseInfra.objects.filter(environment=origindatabase.environment,plan=origindatabase.plan):
# if infra.databases.filter(name=cleaned_data['database_clone']):
# self._errors["database_clone"] = self.error_class([_("this name already exists in the selected environment")])
if len(cleaned_data['database_clone']) > 40:
self._errors["database_clone"] = self.error_class(
[_("Database name too long")])
dbs = origindatabase.team.databases_in_use_for(
origindatabase.environment)
database_alocation_limit = origindatabase.team.database_alocation_limit
LOG.debug("dbs: %s | type: %s" % (dbs, type(dbs)))
if (database_alocation_limit != 0
and len(dbs) >= database_alocation_limit):
LOG.warning(
"The database alocation limit of %s has been exceeded for the team: %s => %s"
%
(database_alocation_limit, origindatabase.team, list(dbs)))
raise forms.ValidationError([
_("The database alocation limit of %s has been exceeded for the team: %s => %s"
) %
(database_alocation_limit, origindatabase.team, list(dbs))
])
driver = DriverFactory.get_driver_class(
origindatabase.plan.engines[0].name)
if cleaned_data[
'database_clone'] in driver.RESERVED_DATABASES_NAME:
raise forms.ValidationError(
_("%s is a reserved database name" %
cleaned_data['database_clone']))
if self._errors:
return cleaned_data
return cleaned_data
class RunCloneForm(BaseRunForm):
build = forms.ModelChoiceField(
label='Build',
queryset=Build.objects.none(),
empty_label=None,
)
class GroupRemoveForm(forms.Form):
remove_group = forms.ModelChoiceField(queryset=Group.objects.all(),
required=True)
class PostForm(forms.ModelForm): category = forms.ModelChoiceField(queryset=Category.objects.all()) class Meta: model = Post fields = ['title', 'category', 'image', 'image_alt', 'is_public', 'content']
class UserRegisterForm(forms.Form):
# FIELDS USUARIO
nome = forms.CharField(label='Nome:', max_length=45)
sobrenome = forms.CharField(label='Sobrenome:', max_length=45)
email = forms.CharField(label='Email:', max_length=75)
password = forms.CharField(label='Senha', widget=forms.PasswordInput)
repetir_password = forms.CharField(label='Confirmação de Senha',
widget=forms.PasswordInput)
tipo_usuario = forms.ModelChoiceField(TipoUsuario,
label='Tipo de Usuário:',
widget=forms.Select())
genero = forms.ModelChoiceField(Genero,
label='Genero:',
widget=forms.Select())
data_nascimento = forms.DateField(
label='Data de Nascimento:', input_formats=settings.DATE_INPUT_FORMATS)
cpf = forms.CharField(label='CPF:', max_length=14)
rg = forms.CharField(label='RG:', max_length=12)
orgaoemissor = forms.CharField(label='Orgão Emissor:', max_length=45)
foto = forms.ImageField(label='Foto:', required=False)
# FIELDS LOGRADOURO
cep = forms.CharField(label='CEP:', max_length=10)
rua = forms.CharField(label='Rua:', max_length=100)
bairro = forms.CharField(label='Bairro:', max_length=45)
cidade = forms.CharField(label='Cidade:', max_length=20)
estado = forms.CharField(label='Estado:', max_length=2)
pais = forms.CharField(label='País:', max_length=45)
# FIELDS ENDERECO
numero = forms.IntegerField(label='Numero:')
complemento = forms.CharField(label='Complemento:', max_length=45)
pontoreferencia = forms.CharField(label='Ponto de referência:',
max_length=45,
widget=forms.Textarea)
def __init__(self, *args, **kwargs):
super(UserRegisterForm, self).__init__(*args, **kwargs)
'''
FIELDS USUARIO
'''
# Frist Name Fields widget
self.fields['nome'].widget.attrs['class'] = 'form-control'
self.fields['nome'].widget.attrs['placeholder'] = 'Digite o nome'
# Last Name Fields widget
self.fields['sobrenome'].widget.attrs['class'] = 'form-control'
self.fields['sobrenome'].widget.attrs[
'placeholder'] = 'Digite o sobrenome'
# Email Fields widget
self.fields['email'].widget.attrs['class'] = 'form-control'
self.fields['email'].widget.attrs['placeholder'] = 'Digite o email'
# Password Fields widget
self.fields['password'].widget.attrs['class'] = 'form-control'
self.fields['password'].widget.attrs[
'placeholder'] = 'Digite uma senha'
# Repetir_senha Fields widget
self.fields['repetir_password'].widget.attrs['class'] = 'form-control'
self.fields['repetir_password'].widget.attrs[
'placeholder'] = 'Repita a senha'
# Tipo_usuario Fields widget
self.fields['tipo_usuario'].widget.attrs['class'] = 'form-control'
self.fields['tipo_usuario'].queryset = TipoUsuario.objects.all()
# Genero Fields widget
self.fields['genero'].widget.attrs['class'] = 'form-control'
self.fields['genero'].queryset = Genero.objects.all()
# Data Nascimento Fields widget
self.fields['data_nascimento'].widget.attrs['class'] = 'form-control'
self.fields['data_nascimento'].widget.attrs[
'placeholder'] = 'Digite a data de nascimento'
# CPF Fields widget
self.fields['cpf'].widget.attrs['class'] = 'form-control'
self.fields['cpf'].widget.attrs['placeholder'] = 'Digite o CPF'
# RG Fields widget
self.fields['rg'].widget.attrs['class'] = 'form-control'
self.fields['rg'].widget.attrs['placeholder'] = 'Digite o RG'
# Orgao Emissor Fields widget
self.fields['orgaoemissor'].widget.attrs['class'] = 'form-control'
self.fields['orgaoemissor'].widget.attrs[
'placeholder'] = 'Digite o Orgao Emissor'
# Foto Fields widget
self.fields['foto'].widget.attrs['class'] = 'form-control'
self.fields['foto'].widget.attrs['placeholder'] = 'Escolha uma foto'
'''
FIELDS LOGRADOURO
'''
# CEP Fields widget
self.fields['cep'].widget.attrs['class'] = 'form-control'
self.fields['cep'].widget.attrs['onblur'] = 'get_cep_data(this.value)'
self.fields['cep'].widget.attrs['placeholder'] = 'Digite o CEP'
# Rua Fields widget
self.fields['rua'].widget.attrs['class'] = 'form-control'
self.fields['rua'].widget.attrs['placeholder'] = 'Digite a rua'
# Bairro Fields widget
self.fields['bairro'].widget.attrs['class'] = 'form-control'
self.fields['bairro'].widget.attrs['placeholder'] = 'Digite o bairro'
# Cidade Fields widget
self.fields['cidade'].widget.attrs['class'] = 'form-control'
self.fields['cidade'].widget.attrs['placeholder'] = 'Digite a cidade'
# Estado Fields widget
self.fields['estado'].widget.attrs['class'] = 'form-control'
self.fields['estado'].widget.attrs['placeholder'] = 'Digite o estado'
# Pais Fields widget
self.fields['pais'].widget.attrs['class'] = 'form-control'
self.fields['pais'].widget.attrs['placeholder'] = 'Digite o pais'
'''
FIELDS ENDERECO
'''
# Numero Fields widget
self.fields['numero'].widget.attrs['class'] = 'form-control'
self.fields['numero'].widget.attrs['placeholder'] = 'Digite o numero'
# Complemento Fields widget
self.fields['complemento'].widget.attrs['class'] = 'form-control'
self.fields['complemento'].widget.attrs[
'placeholder'] = 'Digite o complemento'
# Pontoreferencia Fields widget
self.fields['pontoreferencia'].widget.attrs['class'] = 'form-control'
self.fields['pontoreferencia'].widget.attrs[
'placeholder'] = 'Digite um ponto de referência'
pass
class DatabaseForm(models.ModelForm):
environment = forms.ModelChoiceField(queryset=Environment.objects)
engine = forms.ModelChoiceField(queryset=Engine.objects)
plan = AdvancedModelChoiceField(
queryset=Plan.objects.filter(is_active='True'),
required=False,
widget=forms.RadioSelect,
empty_label=None)
class Meta:
model = Database
fields = [
'name', 'description', 'project', 'environment', 'engine', 'team',
'subscribe_to_email_events', 'is_in_quarantine', 'plan'
]
def __init__(self, *args, **kwargs):
super(DatabaseForm, self).__init__(*args, **kwargs)
self.fields['is_in_quarantine'].widget = forms.HiddenInput()
def _validate_description(self, cleaned_data):
if 'description' in cleaned_data:
if not cleaned_data.get('description', None):
self._errors["description"] = self.error_class(
[_("Description: This field is required.")])
def _validate_project(self, cleaned_data):
if 'project' in cleaned_data:
if not cleaned_data.get('project', None):
self._errors["project"] = self.error_class(
[_("Project: This field is required.")])
def _validate_team(self, cleaned_data):
if 'team' in cleaned_data:
if not cleaned_data['team']:
LOG.warning("No team specified in database form")
self._errors["team"] = self.error_class(
[_("Team: This field is required.")])
def _validate_team_resources(self, cleaned_data):
team = cleaned_data['team']
if team:
dbs = team.databases_in_use_for(cleaned_data['environment'])
database_alocation_limit = team.database_alocation_limit
LOG.debug("dbs: %s | type: %s" % (dbs, type(dbs)))
if (database_alocation_limit != 0
and len(dbs) >= database_alocation_limit):
LOG.warning(
"The database alocation limit of %s has been exceeded for the selected team %s => %s"
% (database_alocation_limit, team, list(dbs)))
self._errors["team"] = self.error_class([
_("The database alocation limit of %s has been exceeded for the selected team: %s"
) % (database_alocation_limit, list(dbs))
])
def _validate_name(self, cleaned_data):
if len(cleaned_data['name']) > 40:
self._errors["name"] = self.error_class(
[_("Database name too long")])
plan = cleaned_data['plan']
class_path = plan.replication_topology.class_path
driver_name = get_replication_topology_instance(class_path).driver_name
driver = DriverFactory.get_driver_class(driver_name)
if cleaned_data['name'] in driver.RESERVED_DATABASES_NAME:
raise forms.ValidationError(
_("%s is a reserved database name" % cleaned_data['name']))
def clean(self):
cleaned_data = super(DatabaseForm, self).clean()
if not self.is_valid():
raise forms.ValidationError(self.errors)
if 'plan' in cleaned_data:
plan = cleaned_data.get('plan', None)
if not plan:
self._errors["plan"] = self.error_class(
[_("Plan: This field is required.")])
self._validate_name(cleaned_data)
self._validate_project(cleaned_data)
self._validate_description(cleaned_data)
self._validate_team(cleaned_data)
if 'environment' in cleaned_data:
environment = cleaned_data.get('environment', None)
database_name = cleaned_data.get('name', None)
if not environment or environment not in plan.environments.all():
raise forms.ValidationError(
_("Invalid plan for selected environment."))
if Database.objects.filter(name=database_name,
environment__name=environment):
self._errors["name"] = self.error_class([
_("this name already exists in the selected environment")
])
del cleaned_data["name"]
self._validate_team_resources(cleaned_data)
if database_name_evironment_constraint(database_name,
environment.name):
raise forms.ValidationError(
_('%s already exists in production!') % database_name)
if self._errors:
return cleaned_data
return cleaned_data
class UpsellForm(happyforms.Form):
price = forms.ModelChoiceField(queryset=Price.objects.active(),
label=_lazy(u'App Price'),
empty_label=None,
required=True)
make_public = forms.TypedChoiceField(choices=APP_PUBLIC_CHOICES,
widget=forms.RadioSelect(),
label=_lazy(
u'When should your app be '
'made available for sale?'),
coerce=int,
required=False)
free = AddonChoiceField(
queryset=Addon.objects.none(),
required=False,
empty_label='',
# L10n: "App" is a paid version of this app. "from" is this app.
label=_lazy(u'App to upgrade from'),
widget=forms.Select())
def __init__(self, *args, **kw):
self.extra = kw.pop('extra')
self.request = kw.pop('request')
self.addon = self.extra['addon']
if 'initial' not in kw:
kw['initial'] = {}
kw['initial']['make_public'] = amo.PUBLIC_IMMEDIATELY
if self.addon.premium:
kw['initial']['price'] = self.addon.premium.price
super(UpsellForm, self).__init__(*args, **kw)
self.fields['free'].queryset = (self.extra['amo_user'].addons.exclude(
pk=self.addon.pk).filter(premium_type__in=amo.ADDON_FREES,
status__in=amo.VALID_STATUSES,
type=self.addon.type))
if len(self.fields['price'].choices) > 1:
# Tier 0 (Free) should not be the default selection.
self.initial['price'] = (Price.objects.active().exclude(
price='0.00')[0])
def clean_make_public(self):
return (amo.PUBLIC_WAIT
if self.cleaned_data.get('make_public') else None)
def save(self):
if 'price' in self.cleaned_data:
premium = self.addon.premium
if not premium:
premium = AddonPremium()
premium.addon = self.addon
premium.price = self.cleaned_data['price']
premium.save()
upsell = self.addon.upsold
if self.cleaned_data['free']:
# Check if this app was already a premium version for another app.
if upsell and upsell.free != self.cleaned_data['free']:
upsell.delete()
if not upsell:
upsell = AddonUpsell(premium=self.addon)
upsell.free = self.cleaned_data['free']
upsell.save()
elif upsell:
upsell.delete()
self.addon.update(make_public=self.cleaned_data['make_public'])
class FacilityForm(forms.Form):
facility = forms.ModelChoiceField(queryset=Facility.objects.all(), required=True)
class AcuerdoPrebasicaForm(ModelForm):
class Meta:
model = acuerdo_prebasica
exclude = ('plaza_disponible', 'estructura_plaza',
'estructura_presupuestaria', 'usuario_creador',
'fecha_creacion', 'usuario_modificador',
'fecha_modificacion')
movimiento = forms.ModelChoiceField(
queryset=subtipos_acuerdos.objects.all(),
widget=forms.Select(attrs={
'class': 'width-40 chosen-select',
'required': 'required'
}))
accion = forms.CharField(
label="Acción #",
widget=forms.TextInput(
attrs={
'size': '10',
'required': 'required',
'pattern': '[0-9]{4,4}',
'title': 'El número de acción debe tener 4 dígitos.'
}))
nacuerdo = forms.CharField(
label="Acuerdo #",
widget=forms.TextInput(
attrs={
'size': '23',
'required': 'required',
'pattern':
'[0-9]{4}[\-]{1}[A-Z]{4}[\-]{1}[0-9]{2}[\-]{1}[0-9]{4}',
'title': 'El número de acuerdo tiene un formato inválido.'
}))
fecha = forms.CharField(label="Fecha parámetro",
widget=forms.TextInput(
attrs={
'required': 'required',
'class': 'form-control date-picker',
'data-date-format': 'yyyy-mm-dd'
}))
vigencia_desde = forms.DateField(
label="Vigencia desde el",
widget=forms.DateInput(
attrs={
'required': 'required',
'class': 'form-control date-picker',
'data-date-format': 'yyyy-mm-dd'
}))
vigencia_hasta = forms.DateField(
label="Hasta",
required=False,
widget=forms.DateInput(attrs={
'class': 'form-control date-picker',
'data-date-format': 'yyyy-mm-dd'
}))
nombres_docente = forms.CharField(
label="Nombres",
widget=forms.TextInput(
attrs={
'size': '30',
'readonly': 'readonly',
'required': 'required',
'pattern': '[a-zA-Z]{3,45}',
'title': 'El nombre del docente no es permitido.'
}))
apellidos_docente = forms.CharField(
label="Apellidos",
widget=forms.TextInput(
attrs={
'size': '30',
'readonly': 'readonly',
'required': 'required',
'pattern': '[a-zA-Z]{3,45}',
'title': 'El nombre del docente no es permitido.'
}))
identidad_docente = forms.CharField(
label="Identidad",
widget=forms.TextInput(
attrs={
'class':
'form-control',
'size':
'18',
'required':
'required',
'pattern':
'[0-9]{13,13}',
'title':
'El número de identidad debe ser numérico y de 13 dígitos.'
}))
sexo_docente = forms.CharField(
label="Género",
widget=forms.TextInput(
attrs={
'class': 'form-control',
'size': '18',
'readonly': 'readonly',
'required': 'required',
'pattern': '[A-Z]{9,9}',
'title': 'El género no puede exceder de 9 letras.'
}))
clave_escalafon_docente = forms.CharField(
label="Clave Escalafon",
widget=forms.TextInput(
attrs={
'class': 'form-control',
'size': '18',
'required': 'required',
'pattern': '[a-zA-Z]{2,4}[\s-]{0,1}[0-9]{1,6}',
'title': 'La clave de escalafon tiene un formato inválido.'
}))
fecha_nacimiento_docente = forms.CharField(
label="Fecha Nacimiento",
widget=forms.TextInput(
attrs={
'required': 'required',
'readonly': 'readonly',
'class': 'form-control date-picker',
'data-date-format': 'yyyy-mm-dd'
}))
colegio1 = forms.ModelChoiceField(
queryset=colegios_magisteriales.objects.all(),
widget=forms.Select(attrs={'required': 'required'}))
departamento = forms.ModelChoiceField(queryset=departamento.objects.all())
municipio = forms.ModelChoiceField(queryset=municipio.objects.all())
aldea = forms.ModelChoiceField(queryset=aldea.objects.all())
cargo = forms.ModelChoiceField(queryset=cargos.objects.all())
estado = forms.ModelChoiceField(queryset=estados_acuerdo.objects.filter(
pk=1))
nombre_centro = forms.CharField(
label="Escuela ",
widget=forms.TextInput(attrs={
'size': '55',
'required': 'required',
'readonly': 'readonly'
}))
def __init__(self, codigo_departamento, codigo_municipio, codigo_aldea,
cargo, *args, **kwargs):
super(AcuerdoPrebasicaForm, self).__init__(*args, **kwargs)
if codigo_departamento:
self.fields['departamento'].queryset = departamento.objects.filter(
codigo_departamento=codigo_departamento)
if codigo_municipio and codigo_departamento:
self.fields['municipio'].queryset = municipio.objects.filter(
departamento__codigo_departamento=codigo_departamento,
codigo_municipio=codigo_municipio)
if codigo_aldea and codigo_municipio and codigo_departamento:
self.fields['aldea'].queryset = aldea.objects.filter(
codigo_departamento=codigo_departamento,
codigo_municipio=codigo_municipio,
codigo_aldea=codigo_aldea)
if cargo:
self.fields['cargo'].queryset = cargos.objects.filter(pk=cargo)
class TodoForm(forms.ModelForm):
short_desc = forms.CharField(widget=forms.TextInput(
attrs={'autocomplete': 'off'}))
group = forms.ModelChoiceField(queryset=Group.objects.none(),
required=False)
assigned_to = forms.ModelChoiceField(queryset=Resource.objects.none(),
required=False)
created_by = forms.CharField(disabled=True, required=False)
context_id = forms.ModelChoiceField(
queryset=Context.objects.all(),
to_field_name='context_id',
required=False,
widget=autocomplete.ModelSelect2(url='context-autocomplete'))
todo_type = forms.ModelChoiceField(
queryset=TodoType.objects.all().order_by('name'),
to_field_name='code',
required=False)
status = forms.ModelChoiceField(
queryset=TodoStatus.objects.all().order_by('name'),
to_field_name='code',
required=False)
start_date = forms.DateField(input_formats=['%d-%b-%Y'],
label='Start Date',
required=False,
widget=forms.DateInput(format='%d-%b-%Y',
attrs={
'autocomplete':
'off',
'placeholder':
'Select a date',
'class':
'datepicker'
}))
end_date = forms.DateField(input_formats=['%d-%b-%Y'],
label='End Date',
required=False,
widget=forms.DateInput(format='%d-%b-%Y',
attrs={
'autocomplete':
'off',
'placeholder':
'Select a date',
'class': 'datepicker'
}))
class Meta:
model = Todo
fields = [
'assigned_to',
'group',
'context_id',
'todo_type',
'short_desc',
'status',
'effort_type',
'effort',
'start_date',
'end_date',
]
def clean(self):
# print ("Calling Clean Start date --> (1)")
start_date = self.cleaned_data['start_date']
end_date = self.cleaned_data['end_date']
if start_date and end_date and end_date < start_date:
raise forms.ValidationError(
'End Date cannot be before Start Date.')
# print ("Calling Clean Start date --> (2)",start_date)
super(TodoForm, self).clean()
def __init__(self, user, mode, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = FormHelper()
self.fields['group'].queryset = Group.objects.filter(
user=user).all().order_by("name")
self.fields['assigned_to'].queryset = Resource.objects.filter(
user__in=User.objects.filter(groups__in=Group.objects.filter(
user=user))).order_by("res_name")
formAction = None
if (mode == 'delete'):
formAction = Submit('save', 'Delete', css_class='btn btn-danger')
elif (mode == 'close'):
formAction = Submit('save',
'Complete',
css_class='btn btn-success')
elif (mode == 'copyas'):
formAction = Submit('save', 'Copy', css_class='btn btn-info')
else:
formAction = Submit('save', 'Save', css_class='btn btn-primary')
self.helper.layout = Layout(
Row(Column('short_desc', css_class='form-group col-md-12 mb-0'),
css_class='form-row'),
Row(Column('context_id', css_class='form-group col-md-12 mb-0'),
css_class='form-row'),
Row(Column('group', css_class='form-group col-md-4 mb-0'),
Column('assigned_to', css_class='form-group col-md-5 mb-0'),
Column('status', css_class='form-group col-md-3 mb-0'),
css_class='form-row'),
Row(Column('todo_type', css_class='form-group col-md-4 mb-0'),
Column('effort_type', css_class='form-group col-md-4 mb-0'),
Column('effort', css_class='form-group col-md-4 mb-0'),
css_class='form-row'),
Row(Column('start_date', css_class='form-group col-md-4 mb-0'),
Column('end_date', css_class='form-group col-md-4 mb-0'),
Column('created_by', css_class='form-group col-md-4 mb-0'),
css_class='form-row'),
Row(
Column(
FormActions(
formAction,
HTML(
'<a class="btn btn-warning" href={% url "todo_index" %}>Cancel</a>'
),
# Button( 'cancel', 'Cancel', css_class="btn btn-md btn-default",data_dismiss="modal")
),
css_class='form-group col-md-12 mb-0'),
css_class='form-row'))
