class Meta:
model = Dataset
fields = "__all__"
widgets = {
'tags': AdminTextInputWidget(attrs={'class': 'vTextField'}),
'states': AdminTextInputWidget(attrs={'class': 'vTextField'}),
'division_names':
AdminTextInputWidget(attrs={'class': 'vTextField'}),
}
class Meta:
model = CompilerProfile
widgets = {
'compile':
AdminTextInputWidget(attrs={
'placeholder':
'gcc -w --std=c99 -O2 -o {BASENAME} {FILENAME} -lm'
}),
'run':
AdminTextInputWidget(attrs={'placeholder': './{BASENAME}'}),
'package_name':
AdminTextInputWidget(attrs={'placeholder': 'gcc'})
}
def _get_form_fields(self):
return OrderedDict((
(self.lookup_kwarg_gte,
CustomIntegerField(label='',
widget=AdminTextInputWidget(
attrs={'placeholder': _('From date')}),
localize=True,
required=False)),
(self.lookup_kwarg_lte,
CustomIntegerField(label='',
widget=AdminTextInputWidget(
attrs={'placeholder': _('To date')}),
localize=True,
required=False)),
))
def __init__(self, domains, attrs=None):
choices = [(d, '@%s' % d) for d in domains]
_widgets = (
AdminTextInputWidget(attrs=attrs),
forms.Select(attrs=attrs, choices=choices)
)
super().__init__(_widgets, attrs)
class CreateAliasWizardForm(forms.Form):
name = forms.CharField(required=True, widget=AdminTextInputWidget())
category = forms.ModelChoiceField(
queryset=Category.objects.all(),
required=True,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if not getattr(self, 'user', None):
self.user = self._request.user
self.set_category_widget(self.user)
def set_category_widget(self, user):
formfield = self.fields['category']
formfield.widget = get_category_widget(formfield, user)
@transaction.atomic
def save(self):
alias = AliasModel.objects.create(
category=self.cleaned_data.get('category'), )
alias_content = AliasContent.objects.create(
alias=alias,
name=self.cleaned_data.get('name'),
language=self.language_code,
)
if is_versioning_enabled():
from djangocms_versioning.models import Version
Version.objects.create(content=alias_content,
created_by=self._request.user)
emit_content_change([alias_content])
return alias
def get_customer_admin_form():
attrs = {}
for name, f in forms.fields_for_model(CustomerAddress).items():
if isinstance(f, forms.CharField):
f.widget = AdminTextInputWidget()
attrs['address_{}'.format(name)] = f
return type('CustomerAdminFormBase', (forms.ModelForm, ), attrs)
def _get_form_fields(self):
return OrderedDict(
(
(self.lookup_kwarg_field, CharField(
label='',
required=False,
widget=AdminTextInputWidget(attrs={'placeholder': self.lookup_kwarg_field})
)),
(self.lookup_kwarg_new, CharField(
label='',
required=False,
widget=AdminTextInputWidget(attrs={'placeholder': self.lookup_kwarg_new})
)),
(self.lookup_kwarg_old, CharField(
label='',
required=False,
widget=AdminTextInputWidget(attrs={'placeholder': self.lookup_kwarg_old})
)),
)
)
class PersonForm(forms.ModelForm):
name = forms.CharField(
label='Nome',
required=True,
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
public_place = forms.CharField(
label='Endereço completo',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
number = forms.CharField(
label='Número',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
city = forms.CharField(
label='Cidade',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
state = forms.CharField(
label='Estado',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
zipcode = forms.CharField(
label='Cep',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
neighborhood = forms.CharField(
label='Bairro',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
balance = forms.DecimalField(
label='Saldo',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}))
date_of_turn = forms.DateField(
label='Dt. Giro',
widget=forms.TextInput(attrs={'class': 'form-control input-lg'}))
date_return = forms.DateField(required=False)
# class="form-control input-lg"
def __init__(self, *args, **kwargs):
super(PersonForm, self).__init__(*args, **kwargs)
self.fields['balance'].localize = True
self.fields['balance'].widget.is_localized = True
def clean_name(self):
name = self.cleaned_data['name']
return name.upper()
class Meta:
model = Person
exclude = ['date_return', 'user']
fields = '__all__'
ordering = ('name', )
class MovimentoForm(forms.ModelForm):
person = forms.ModelChoiceField(
label='Pessoa',
widget=forms.Select(attrs={'class': 'form-control'}),
required=True,
queryset=Person.objects.all())
transaction_kind = forms.ChoiceField(
label='Tipo Movimento',
widget=forms.Select(attrs={'class': 'form-control'}),
required=True,
choices=TRANSACTION_KIND)
value_moved = forms.DecimalField(
label='Valor Movimentado',
widget=AdminTextInputWidget(attrs={'class': 'form-control input-lg'}),
max_digits=10,
decimal_places=2)
created = forms.DateField(
label='Dt. Movimento',
widget=forms.TextInput(attrs={'class': 'form-control input-lg'}))
date_return = forms.DateField(
label='Dt. Retorno',
widget=forms.TextInput(attrs={'class': 'form-control input-lg'}))
# def __init__(self, user, *args, **kwargs):
# super(MovimentoForm, self).__init__(*args, **kwargs)
# self.fields['moved'].widget.is_localized = True
def __init__(self, user_id, *args, **kwargs):
super().__init__(*args, **kwargs)
print(user_id)
# user_id ta sendo passado via GET da VIEW, assim pego o id do usuario para meu queryset.
self.fields['person'].queryset = Person.objects.filter(user_id=user_id)
self.fields['value_moved'].localize = True
self.fields['value_moved'].widget.is_localized = True
"""
A variavel pk acima vem da view atendimento_create(request, pk): onde envio esse valor
no GET na linha 29
context = {'form': AtendimentoForm(pk)}
"""
class Meta:
model = Movimento
exclude = ['modified', 'user']
fields = '__all__'
class SeoEntryAdminMixin(object):
"""
Mixin for the SEO fields.
"""
FIELDSET_SEO = (_('SEO settings'), {
'fields': ('meta_keywords', 'meta_description'),
'classes': ('collapse',),
})
# AbstractEntryBaseAdmin allows to specify the widgets by field name,
# which formfield_overrides doesn't support by default.
formfield_overrides = {
'meta_keywords': {
'widget': AdminTextInputWidget(attrs={'class': 'vLargeTextField'})
},
'meta_description': {
'widget': AdminTextareaWidget(attrs={'rows': 3})
},
}
class CreateAliasForm(BaseCreateAliasForm):
name = forms.CharField(required=True, widget=AdminTextInputWidget())
site = forms.ModelChoiceField(
queryset=Site.objects.all(),
required=False,
)
category = forms.ModelChoiceField(
queryset=Category.objects.all(),
required=True,
)
replace = forms.BooleanField(
label=_('Replace current plugin'),
help_text=_('Replace current plugin with alias'),
required=False,
)
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super().__init__(*args, **kwargs)
if not has_plugin_permission(self.user, 'Alias', 'add'):
self.fields['replace'].widget = forms.HiddenInput()
self.set_category_widget(self.user)
self.fields["site"].initial = get_current_site()
def clean(self):
cleaned_data = super().clean()
if AliasContent.objects.filter(
name=cleaned_data.get('name'),
language=cleaned_data.get('language'),
alias__category=cleaned_data.get('category'),
).exists():
raise forms.ValidationError(
_('Alias with this Name and Category already exists.')
)
return cleaned_data
def set_category_widget(self, user):
formfield = self.fields['category']
formfield.widget = get_category_widget(formfield, user)
def get_plugins(self):
plugin = self.cleaned_data.get('plugin')
placeholder = self.cleaned_data.get('placeholder')
if placeholder:
plugins = placeholder.get_plugins(
self.cleaned_data.get('language'),
)
else:
plugins = [plugin] + list(plugin.get_descendants())
return list(plugins)
def save(self):
alias = AliasModel.objects.create(
category=self.cleaned_data.get('category'),
site=self.cleaned_data.get('site'),
)
alias_content = AliasContent.objects.create(
alias=alias,
name=self.cleaned_data.get('name'),
language=self.cleaned_data.get('language'),
)
if is_versioning_enabled():
from djangocms_versioning.models import Version
Version.objects.create(content=alias_content, created_by=self.user)
if self.cleaned_data.get('replace'):
placeholder = self.cleaned_data.get('placeholder')
plugin = self.cleaned_data.get('plugin')
source_plugins = None
else:
placeholder, plugin = None, None
source_plugins = self.get_plugins()
new_plugin = alias_content.populate(
replaced_placeholder=placeholder,
replaced_plugin=plugin,
plugins=source_plugins,
)
return alias, alias_content, new_plugin
class Meta:
model = FileExtension
widgets = {
'extension':
AdminTextInputWidget(attrs={'placeholder': '*.{File extension}'})
}
class FaqBaseModelAdmin(MultiSiteAdminMixin, TranslatableAdmin,
PlaceholderFieldAdmin):
"""
Base admin for FAQ questions
"""
filter_site = appsettings.FLUENT_FAQ_FILTER_SITE_ID
list_display = ('title', 'language_column', 'modification_date',
'actions_column')
form = FaqBaseModelForm
search_fields = ('translations__slug', 'translations__title')
# Using fieldnames here works because formfield_for_dbfield() is overwritten.
formfield_overrides = {
'meta_keywords': {
'widget': AdminTextInputWidget(attrs={'class': 'vLargeTextField'})
},
'meta_description': {
'widget': AdminTextareaWidget(attrs={'rows': 3})
},
}
FIELDSET_GENERAL = (None, {
'fields': (
'title',
'slug',
),
})
FIELDSET_SEO = (_('SEO settings'), {
'fields': ('meta_keywords', 'meta_description'),
'classes': ('collapse', ),
})
FIELDSET_PUBLICATION = (
_('Publication settings'),
{
'fields': ('order', ),
#'classes': ('collapse',),
})
fieldsets = (
FIELDSET_GENERAL,
FIELDSET_SEO,
FIELDSET_PUBLICATION,
)
class Media:
css = {'all': ('fluent_faq/admin/admin.css', )}
def get_prepopulated_fields(self, request, obj=None):
# Needed for django-parler
return {
'slug': ('title', ),
}
def save_model(self, request, obj, form, change):
# Automatically store the user in the author field.
if not change:
obj.author = request.user
obj.save()
def formfield_for_dbfield(self, db_field, **kwargs):
"""
Allow formfield_overrides to contain field names too.
"""
overrides = self.formfield_overrides.get(db_field.name)
if overrides:
kwargs.update(overrides)
return super(FaqBaseModelAdmin,
self).formfield_for_dbfield(db_field, **kwargs)
def render_change_form(self,
request,
context,
add=False,
change=False,
form_url='',
obj=None):
# When the page is accessed via a pagetype, warn that the node can't be previewed yet.
context['preview_error'] = ''
if 'fluent_pages' in settings.INSTALLED_APPS:
from fluent_pages.urlresolvers import PageTypeNotMounted, MultipleReverseMatch
try:
self._reverse_faqpage_index(request, obj)
except PageTypeNotMounted:
from fluent_faq.pagetypes.faqpage.models import FaqPage
context['preview_error'] = ugettext(
"The {object_name} can't be previewed yet, a '{page_type_name}' page needs to be created first."
).format(object_name=self.model._meta.verbose_name,
page_type_name=FaqPage._meta.verbose_name)
except MultipleReverseMatch:
# When 'faqquestion_index is ambiguous (because there are multiple FAQ nodes in the fluent-pages tree),
# the edit page will automatically pick an option.
pass
except NoReverseMatch:
# Since forgetting the pagetype app is easy, give off a warning to help developers
# find their way with these apps.
raise ImproperlyConfigured(
"To use django-fluent-faq, either include('fluent_faq.urls') in the URLConf, "
"or add the 'fluent_faq.pagetypes.faqpage' app to the INSTALLED_APPS."
)
return super(FaqBaseModelAdmin,
self).render_change_form(request, context, add, change,
form_url, obj)
def _reverse_faqpage_index(self, request, obj=None):
# Internal method with "protected access" to handle translation differences.
# This is only called when 'fluent_pages' is in the INSTALLED_APPS.
return mixed_reverse('faqquestion_index')
@classmethod
def get_actions_column(cls, faqquestion):
return mark_safe(u' '.join(
conditional_escape(a)
for a in cls._actions_column_icons(faqquestion)))
@classmethod
def _actions_column_icons(cls, object):
actions = []
if cls.can_preview_object(object):
try:
url = object.get_absolute_url()
except (NoReverseMatch, TranslationDoesNotExist):
# A FaqQuestion is already added, but the URL can no longer be resolved.
# This can either mean that urls.py is missing a 'fluent_faq.urls' (unlikely),
# or that this is a PageTypeNotMounted exception because the "FAQ page" node was removed.
# In the second case, the edit page should still be reachable, and the "view on site" link will give an alert.
pass
else:
actions.append(
mark_safe(
u'<a href="{url}" title="{title}" target="_blank"><img src="{static}fluent_faq/img/admin/world.gif" width="16" height="16" alt="{title}" /></a>'
.format(url=url,
title=_('View on site'),
static=settings.STATIC_URL)))
return actions
@classmethod
def can_preview_object(cls, object):
""" Override whether the node can be previewed. """
#return hasattr(faqquestion, 'get_absolute_url') and faqquestion.is_published
return True
def actions_column(self, faqquestion):
return self.get_actions_column(faqquestion)
actions_column.allow_tags = True
actions_column.short_description = _('Actions')
class AppUserEditForm(forms.ModelForm):
tools_access_role_arn = forms.CharField(
label="Tools access IAM role arn",
help_text="The arn for the IAM role required to start local tools",
required=False,
widget=AdminTextInputWidget(),
)
home_directory_efs_access_point_id = forms.CharField(
label="Home directory ID",
help_text="EFS Access Point ID",
max_length=128,
required=False,
empty_value=None,
widget=AdminTextInputWidget(),
)
can_start_all_applications = forms.BooleanField(
label="Can start local tools",
help_text="For JupyterLab, rStudio and pgAdmin",
required=False,
)
can_develop_visualisations = forms.BooleanField(
label="Can develop visualisations",
help_text="To deploy and manage visualisations from code in Gitlab",
required=False,
)
can_access_appstream = forms.BooleanField(label="Can access AppStream",
help_text="For SPSS and STATA",
required=False)
can_access_quicksight = forms.BooleanField(
label="Can access QuickSight",
help_text=
"Note: the user must also be given separate access to AWS QuickSight via DIT SSO",
required=False,
)
authorized_master_datasets = forms.ModelMultipleChoiceField(
required=False,
widget=FilteredSelectMultiple("master datasets", False),
queryset=MasterDataset.objects.live().filter(
user_access_type=UserAccessType.REQUIRES_AUTHORIZATION).order_by(
"name"),
)
authorized_data_cut_datasets = forms.ModelMultipleChoiceField(
required=False,
widget=FilteredSelectMultiple("data cut datasets", False),
queryset=DataCutDataset.objects.live().filter(
user_access_type=UserAccessType.REQUIRES_AUTHORIZATION).order_by(
"name"),
)
authorized_visualisations = forms.ModelMultipleChoiceField(
label="Authorized visualisations",
required=False,
widget=FilteredSelectMultiple("visualisations", False),
queryset=None,
)
class Meta:
model = get_user_model()
fields = "__all__"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
instance = kwargs["instance"]
self.fields[
"tools_access_role_arn"].initial = instance.profile.tools_access_role_arn
self.fields["tools_access_role_arn"].widget.attrs[
"class"] = "vTextField"
self.fields[
"home_directory_efs_access_point_id"].initial = instance.profile.home_directory_efs_access_point_id
self.fields["home_directory_efs_access_point_id"].widget.attrs[
"class"] = "vTextField"
self.fields[
"can_start_all_applications"].initial = instance.user_permissions.filter(
codename="start_all_applications",
content_type=ContentType.objects.get_for_model(
ApplicationInstance),
).exists()
self.fields[
"can_develop_visualisations"].initial = instance.user_permissions.filter(
codename="develop_visualisations",
content_type=ContentType.objects.get_for_model(
ApplicationInstance),
).exists()
self.fields[
"can_access_appstream"].initial = instance.user_permissions.filter(
codename="access_appstream",
content_type=ContentType.objects.get_for_model(
ApplicationInstance),
).exists()
self.fields[
"can_access_quicksight"].initial = instance.user_permissions.filter(
codename="access_quicksight",
content_type=ContentType.objects.get_for_model(
ApplicationInstance),
).exists()
self.fields[
"authorized_master_datasets"].initial = MasterDataset.objects.live(
).filter(datasetuserpermission__user=instance)
self.fields[
"authorized_data_cut_datasets"].initial = DataCutDataset.objects.live(
).filter(datasetuserpermission__user=instance)
self.fields[
"authorized_visualisations"].initial = VisualisationCatalogueItem.objects.live(
).filter(visualisationuserpermission__user=instance)
self.fields[
"authorized_visualisations"].queryset = VisualisationCatalogueItem.objects.live(
).order_by("name", "id")
