class VisualizationAdmin(admin.ModelAdmin):
formfield_overrides = {
models.JSONField: {
'widget': JSONEditorWidget(attrs={'initiaĺ': 'parsed'})
},
}
#
# Searchable fields
#
search_fields = ['description']
list_display = (
'name',
'objective',
'description',
'last_change_date',
)
list_filter = ('objective', )
save_as = True
date_hierarchy = ('creation_date')
# view_on_site = False
def response_change(self, request, obj, post_url_continue=None):
"""This makes the response after adding go to another apps changelist for some model"""
return HttpResponseRedirect(reverse("reporting:Visualization_list"))
class DomainAdmin(admin.ModelAdmin, DynamicArrayMixin):
actions = ["add_to_wl", "remove_from_wl"]
formfield_overrides = {
models.JSONField: {"widget": JSONEditorWidget()},
}
def add_to_wl(self, request, queryset):
for item in queryset:
wl = Whitelist(value=item.domain, type="domain")
wl.save()
item.whitelisted = True
item.save()
add_to_wl.short_description = "Add selected domains to whitelist"
def remove_from_wl(self, request, queryset):
for item in queryset:
item.whitelisted = False
item.save()
wls = Whitelist.objects.filter(
value__in=[item.domain for item in queryset], type="domain"
)
wls.delete()
remove_from_wl.short_description = "Remove selected domain from whitelist"
list_display = ("domain", "whois", "whitelisted")
inlines = [ReportInline]
search_fields = ["domain"]
class SphereAdmin(SphereManagersAdminMixin[Sphere], SimpleHistoryAdmin):
formfield_overrides = {
JSONField: {
"widget": JSONEditorWidget(options={"schema": SETTINGS_JSON_SCHEMA})
},
}
list_display = ("name", "site", "is_open")
list_filter = ("is_open",)
class Meta:
model = Variables
fields = ('jsonfield',)
widgets = {
'jsonfield': JSONEditorWidget(mode='code')
}
class ReportAdmin(admin.ModelAdmin, DynamicArrayMixin):
formfield_overrides = {
models.JSONField: {"widget": JSONEditorWidget()},
}
list_display = ("analyzer", "content_type", "object_id", "taxonomies", "success")
list_filter = ("analyzer", "success")
class EngagementAdmin(admin.ModelAdmin):
list_display = [
'__str__',
'status',
'partner',
'date_of_field_visit',
'engagement_type',
'start_date',
'end_date',
]
list_filter = [
'status',
'start_date',
'end_date',
'status',
'engagement_type',
]
readonly_fields = (
'status',
'partner',
)
search_fields = 'partner__name', 'agreement__auditor_firm__name',
fields = (
'unique_id',
'engagement_type',
'status',
'start_date',
'end_date',
'partner',
'partner_contacted_at',
'total_value',
'exchange_rate',
'date_of_field_visit',
'date_of_draft_report_to_ip',
'date_of_comments_by_ip',
'date_of_draft_report_to_unicef',
'date_of_comments_by_unicef',
'date_of_report_submit',
'date_of_final_report',
'date_of_cancel',
'cancel_comment',
'internal_controls',
'final_report',
'audited_expenditure',
'financial_findings',
'audit_opinion',
'description',
'finding',
'pending_unsupported_amount',
'findings',
)
formfield_overrides = {
JSONField: {
'widget': JSONEditorWidget(attrs={'initial': 'parsed'})
},
# models.ManyToManyField: {'widget': FilteredSelectMultiple('indicator', is_stacked=False)}
}
class Meta:
model = LogConsultaEOL
fields = ('json', )
widgets = {
# choose one mode from ['text', 'code', 'tree', 'form', 'view']
'json': JSONEditorWidget(mode='form', height='700px', width='100%')
}
class BestPracticeTemplateAdmin(admin.ModelAdmin):
list_display = ('title', 'scope')
list_filter = ('scope', )
formfield_overrides = {
fields.JSONField: {
'widget': JSONEditorWidget(mode='code')
},
}
prepopulated_fields = {"slug": ("title", )}
class SubmissionAdmin(admin.ModelAdmin):
"""Admin interface for the Submission model."""
form = SubmissionAdminForm
formfield_overrides = {
fields.JSONField: {
"widget": JSONEditorWidget(mode="view")
},
}
class ScenarioAdmin(admin.ModelAdmin):
formfield_overrides = {
models.JSONField: {
'widget': JSONEditorWidget(attrs={'initiaĺ': 'parsed'})
},
}
list_display = ('name', 'scenario_no', 'description')
save_as = True
view_on_site = False
date_hierarchy = ('creation_date')
class Meta:
model = LegalDocument
fields = '__all__'
widgets = {
'metadata':
JSONEditorWidget(options={
'mode': 'view',
'modes': ['view']
}),
}
class ChannelMembershipConfigAdmin(admin.ModelAdmin):
"""Admin for ChannelMembershipConfig"""
model = ChannelMembershipConfig
formfield_overrides = {
fields.JSONField: {
"widget": JSONEditorWidget(
options={
"mode": "tree",
"schema": {
"type": "object",
"properties": {
"email__iendswith": {"type": "string"},
"social_auth_provider": {
"type": "array",
"items": {
"type": "string",
"enum": ["saml", "micromasters"],
},
"minItems": 1,
},
"moira_lists": {
"type": "array",
"items": {"type": "string"},
"minItems": 0,
},
},
"minProperties": 1,
"additionalProperties": False,
},
"templates": [
{
"text": "Email suffix",
"title": "Email suffix",
"field": "email__endswith",
"value": "@example.com",
},
{
"text": "Social Auth",
"title": "Social Auth",
"field": "social_auth_provider",
"value": [""],
},
{
"text": "Moira Lists",
"title": "Moira Lists",
"field": "moira_lists",
"value": [""],
},
],
}
)
}
}
class CrudPropertyInline(OrderableAdmin, admin.TabularInline):
ordering_field = "order"
classes = ('collapse', )
verbose_name = _("Feature property")
verbose_name_plural = _("Feature properties")
model = models.CrudViewProperty
form = forms.CrudPropertyForm
extra = 0
formfield_overrides = {
fields.JSONField: {'widget': JSONEditorWidget(height=200)},
}
class DocumentCollectionBaseAdmin(admin.ModelAdmin):
raw_id_fields = (
'user',
'documents',
)
save_on_top = True
search_fields = ('title', )
date_hierarchy = 'created_at'
list_display = ('title', 'created_at', 'public', 'listed', 'user',
'get_document_count', 'processed_documents_percentage')
prepopulated_fields = {'slug': ('title', )}
formfield_overrides = {
JSONField: {
'widget':
JSONEditorWidget(
# TODO: JS does not work with CSP
# options={'schema': SETTINGS_SCHEMA}
)
},
}
readonly_fields = ('uid', 'created_at')
def get_queryset(self, request):
qs = super().get_queryset(request)
qs = qs.annotate(
document_count=Count('documents'),
ready_document_count=Count('documents',
filter=Q(documents__pending=False)),
)
return qs
def get_document_count(self, obj):
return obj.document_count
get_document_count.admin_order_field = 'document_count'
get_document_count.short_description = _('Documents')
def processed_documents_percentage(self, obj):
if not obj.document_count:
return '-'
return '{:.2f}%'.format(obj.ready_document_count / obj.document_count *
100)
processed_documents_percentage.admin_order_field = 'ready_document_count'
processed_documents_percentage.short_description = _('Processed')
def get_inline_instances(self, request, obj=None):
''' Only show inline for docs with fewer than 31 pages'''
if obj is not None:
doc_count = obj.documents.count()
if doc_count < 31:
return super().get_inline_instances(request, obj=obj)
return []
class ReportInline(GenericTabularInline):
formfield_overrides = {
models.JSONField: {"widget": JSONEditorWidget()},
}
def has_add_permission(self, request, obj=None):
return False
def has_delete_permission(self, request, obj=None):
return False
model = Report
extra = 0
class MailAdmin(LeafletGeoAdmin, DynamicArrayMixin):
formfield_overrides = {
models.JSONField: {"widget": JSONEditorWidget()},
}
readonly_fields = (
"parent",
"message_id",
"subject",
"date",
"text_plain",
"text_html",
"text_not_managed",
"sender_ip_address",
"to_domains",
"attachments",
"spf",
"dmark",
"arc",
"dkim",
)
exclude = (
"tags",
"ips",
"urls",
"addresses",
"search_vector",
"attachments_path",
"eml_path",
"geom",
)
def get_queryset(self, request):
return (
super()
.get_queryset(request)
.prefetch_related("tags", "attachments", "ips", "urls")
)
inlines = [AttachmentInline, AddressesInline, UrlsInline, IpsInline]
list_display = (
"submission_date",
"short_id",
"short_subject",
"count_iocs",
"tag_list",
)
list_filter = ("submission_date", "official_response", "progress")
search_fields = ["subject"]
class BestPracticeAdmin(admin.ModelAdmin):
list_display = ('title', 'course', 'courselet', 'active', 'scope')
list_filter = ('active', 'template__scope')
formfield_overrides = {
fields.JSONField: {
'widget': JSONEditorWidget(mode='code')
},
}
def title(self, ob):
return ob.template.title
def scope(self, ob):
return ob.template.scope
class CalculationAdmin(admin.ModelAdmin):
fields = ('user', 'workflow', 'workflow_data', 'results_data', 'logfile',
'result_group')
search_fields = ['results_data', 'workflow_data']
list_filter = ('user', )
list_display = ('workflow', 'result_group', 'creation_date', 'user')
date_hierarchy = ('creation_date')
formfield_overrides = {
models.JSONField: {
'widget': JSONEditorWidget(attrs={'initiaĺ': 'parsed'})
},
}
save_as = False
view_on_site = False
class PlaybookAdmin(admin.ModelAdmin):
formfield_overrides = {
models.JSONField: {
'widget': JSONEditorWidget(attrs={'initial': 'parsed'})
}
}
#
# Searchable fields
#
search_fields = ['description']
list_display = (
'pk',
'name',
'type',
'last_change_date',
)
list_filter = ('type', )
save_as = True
view_on_site = False
date_hierarchy = ('creation_date')
class InternalReportAdmin(admin.ModelAdmin):
list_display = ('generated_date', 'type', 'status', 'context')
list_filter = ('context', 'type', 'status')
readonly_fields = (
'context',
'type',
'status',
'generated_date',
)
exclude = ('generated', )
formfield_overrides = {
TextField: {
'widget': JSONEditorWidget(mode='form')
},
}
@staticmethod
def generated_date(obj):
return format_date_long(obj.generated)
class DocumentPortalAdmin(admin.ModelAdmin):
prepopulated_fields = {'slug': ('title', )}
search_fields = ('title', )
date_hierarchy = 'created_at'
list_display = ('title', 'created_at', 'public', 'get_document_count',
'processed_documents_percentage')
list_filter = ('public', )
formfield_overrides = {
JSONField: {
'widget':
JSONEditorWidget(
# TODO: JS does not work with CSP
# options={'schema': SETTINGS_SCHEMA}
)
},
}
def get_queryset(self, request):
qs = super().get_queryset(request)
qs = qs.annotate(
document_count=Count('document'),
ready_document_count=Count('document',
filter=Q(document__pending=False,
document__num_pages__gt=0)),
)
return qs
def get_document_count(self, obj):
return obj.document_count
get_document_count.admin_order_field = 'document_count'
get_document_count.short_description = _('Documents')
def processed_documents_percentage(self, obj):
if not obj.document_count:
return '-'
return '{:.2f}%'.format(obj.ready_document_count / obj.document_count *
100)
processed_documents_percentage.admin_order_field = 'ready_document_count'
processed_documents_percentage.short_description = _('Processed')
class LimitflowAdmin(admin.ModelAdmin):
formfield_overrides = {
# JSONField: {'widget': JSONEditor},
models.JSONField: {
'widget': JSONEditorWidget(attrs={'initial': 'parsed'})
}
}
#
# Searchable fields
#
search_fields = ['workflow_description']
list_display = (
'workflow_id',
'name',
'workflow_description',
'last_change_date',
)
list_filter = ('workflow_type', 'workflow_status')
save_as = True
view_on_site = False
date_hierarchy = ('creation_date')
class BaseModelAdmin(admin.ModelAdmin):
readonly_fields = ['created', 'modified']
save_as = True
paginator = CachingPaginator
formfield_overrides = {
models.JSONField: {
'widget': JSONEditorWidget(mode='tree')
},
}
def formfield_for_dbfield(self, db_field, **kwargs):
formfield = super().formfield_for_dbfield(db_field, **kwargs)
if isinstance(db_field,
models.fields.CharField) and db_field.name in getattr(
self, 'textarea_fields', []):
formfield.widget = forms.Textarea(attrs=formfield.widget.attrs)
return formfield
class Meta:
abstract = True
class ExtractedDumpAdmin(admin.ModelAdmin):
formfield_overrides = {
models.JSONField: {
"widget": JSONEditorWidget(options={
"mode": "view",
"modes": ["view"]
})
},
}
list_display = ("result", "sha256", "path")
list_filter = ("clamav", )
search_fields = ("sha256", )
readonly_fields = (
"result",
"sha256",
"clamav",
"vt_report",
"path",
)
class Meta:
model = MetadataField
fields = '__all__'
widgets = {'type_settings': JSONEditorWidget(mode='code')}
class Meta:
model = Metadata
fields = '__all__'
widgets = {'values': JSONEditorWidget(mode='code')}
class IndicatorAdmin(ImportExportModelAdmin):
form = IndicatorForm
# formset = IndicatorFormSet
resource_class = IndicatorResource
search_fields = (
'ai_indicator',
'name',
)
list_filter = (
'activity__database__reporting_year',
'activity__database',
'activity',
'master_indicator',
'master_indicator_sub',
'master_indicator_sub_sub',
'individual_indicator',
'calculated_indicator',
'hpm_indicator',
'separator_indicator',
'tag_gender',
'tag_age',
'tag_nationality',
'tag_disability',
'tag_programme',
)
suit_list_filter_horizontal = (
'activity__database__reporting_year',
'activity__database',
'activity',
'master_indicator',
'master_indicator_sub',
'master_indicator_sub_sub',
'individual_indicator',
'calculated_indicator',
'hpm_indicator',
'separator_indicator',
'tag_gender',
'tag_age',
'tag_nationality',
'tag_disability',
)
list_display = (
'id',
'ai_indicator',
'awp_code',
'label',
'target',
'target_sector',
'units',
'activity',
'category',
#'sequence',
'master_indicator',
'is_sector',
'is_section',
'support_disability',
# 'values_tags'
)
filter_horizontal = (
'sub_indicators',
'summation_sub_indicators',
)
list_editable = (
'awp_code',
'target',
'target_sector',
#'sequence',
'master_indicator',
'is_sector',
'is_section',
'support_disability',
# 'values_tags'
)
formfield_overrides = {
JSONField: {
'widget': JSONEditorWidget(attrs={'initial': 'parsed'})
},
# models.ManyToManyField: {'widget': FilteredSelectMultiple('indicator', is_stacked=False)}
}
fieldsets = [
('Basic infos', {
'classes': (
'suit-tab',
'suit-tab-general',
),
'fields': [
'ai_indicator',
'awp_code',
'name',
'label',
'description',
'explication',
'activity',
'list_header',
'type',
'reporting_level',
'target',
'target_sector',
'target_sub_total',
'cumulative_results',
'units',
'category',
'status',
'status_color',
'none_ai_indicator',
'funded_by',
'sequence',
'is_sector',
'is_section',
'support_disability',
]
}),
('Tags', {
'classes': (
'suit-tab',
'suit-tab-general',
),
'fields': [
'tag_age',
'tag_gender',
'tag_nationality',
'tag_disability',
'tag_programme',
'hpm_indicator',
]
}),
('Sub indicators', {
'classes': (
'suit-tab',
'suit-tab-general',
),
'fields': [
'master_indicator',
'master_indicator_sub',
'master_indicator_sub_sub',
'individual_indicator',
'separator_indicator',
'calculated_indicator',
'calculated_percentage',
'measurement_type',
'denominator_indicator',
'denominator_multiplication',
'numerator_indicator',
'sub_indicators',
'summation_sub_indicators',
]
}),
('Calculated Values', {
'classes': (
'suit-tab',
'suit-tab-report-values',
),
'fields': [
'values',
'values_gov',
'values_partners',
'values_partners_gov',
'cumulative_values',
]
}),
('Calculated Values sector', {
'classes': (
'suit-tab',
'suit-tab-report-values-sector',
),
'fields': [
'values_sector',
'values_sites_sector',
'values_partners_sector',
'values_partners_sites_sector',
'cumulative_values_sector',
'values_tags_sector',
]
}),
('Calculated HPM Values', {
'classes': (
'suit-tab',
'suit-tab-hpm-values',
),
'fields': [
'values_hpm',
'values_tags',
'cumulative_values_hpm',
]
}),
('Calculated Values live', {
'classes': (
'suit-tab',
'suit-tab-live-values',
),
'fields': [
'values_live',
'values_gov_live',
'values_partners_live',
'values_partners_gov_live',
'cumulative_values_live',
]
}),
]
suit_form_tabs = (
('general', 'Indicator'),
('report-values', 'Report values'),
('report-values-sector', 'Report values sector'),
('hpm-values', 'HPM values'),
('live-values', 'Live values'),
)
class DatabaseAdmin(ImportExportModelAdmin, nested_admin.NestedModelAdmin):
form = DatabaseForm
resources = DatabaseResource
inlines = [
# ActivityInlineAdmin,
]
list_filter = (
'section',
'reporting_year',
'is_funded_by_unicef',
)
list_display = (
'ai_id',
'name',
'label',
'reporting_year',
'focal_point',
'mapped_db',
'is_funded_by_unicef',
'is_sector',
)
readonly_fields = ('description', 'country_name', 'ai_country_id')
actions = [
're_formatting_json',
'import_basic_data',
'update_basic_data',
'import_only_new',
# 'import_data',
# 'import_reports',
'import_reports_forced',
'link_indicators_data',
'calculate_indicators_values',
'calculate_indicators_cumulative_results',
'calculate_indicators_status',
'reset_indicators_values',
'update_indicators_report',
'update_hpm_report',
'reset_hpm_indicators_values',
'update_indicators_hpm',
'calculate_indicators_cumulative_hpm',
'calculate_indicators_tags_hpm',
'calculate_indicators_tags',
'update_partner_data',
'generate_indicator_tags',
'calculate_sum_target',
'update_indicator_list_header',
'update_indicator_name',
]
fieldsets = [
(None, {
'classes': (
'suit-tab',
'suit-tab-general',
),
'fields': [
'ai_id',
'db_id',
'name',
'label',
'username',
'password',
'section',
'reporting_year',
'focal_point',
'focal_point_sector',
'mapped_db',
'is_funded_by_unicef',
'is_sector',
'description',
'country_name',
'ai_country_id',
'dashboard_link',
]
}),
('Extraction mapping', {
'classes': (
'suit-tab',
'suit-tab-general',
),
'fields': [
'mapping_extraction1',
'mapping_extraction2',
'mapping_extraction3',
]
}),
(
'Activities',
{
'classes': (
'suit-tab',
'suit-tab-activities',
),
'fields': [
# 'ai_id',
# 'name',
# 'location_type',
]
}),
]
suit_form_tabs = (
('general', 'Database'),
('activities', 'Activities'),
)
def re_formatting_json(self, request, queryset):
from .utilities import import_data_v4
objects = 0
for db in queryset:
objects += import_data_v4(db)
self.message_user(request, "{} objects created.".format(objects))
def import_basic_data(self, request, queryset):
objects = 0
for db in queryset:
objects += db.import_data()
self.message_user(request, "{} objects created.".format(objects))
import_basic_data.short_description = 'Step 0: Import Indicators basic structure (only once - ask Ali before!!!)'
def update_basic_data(self, request, queryset):
objects = 0
for db in queryset:
objects += db.import_data(import_new=False, update_only=True)
self.message_user(request, "{} objects created.".format(objects))
update_basic_data.short_description = 'Step 0a: Update Indicators basic data - ' \
'Update only (only once - ask Ali before!!!)'
def import_only_new(self, request, queryset):
objects = 0
for db in queryset:
objects += db.import_data(import_new=True)
self.message_user(request, "{} objects created.".format(objects))
import_only_new.short_description = 'Step 0b: Import only new Indicators basic data -' \
' Import new indicators only(only once - ask Ali before!!!)'
def update_partner_data(self, request, queryset):
for db in queryset:
objects = update_partner_data(db)
self.message_user(
request,
"{}-{} ActivityInfo's partners created for database: ".format(
objects, db))
def generate_indicator_tags(self, request, queryset):
reports = 0
for db in queryset:
reports = generate_indicator_tag(db.ai_id)
self.message_user(request, "{} objects updated.".format(reports))
def import_data(self, request, queryset):
for db in queryset:
r_script_command_line('ai_generate_excel.R', db)
self.message_user(
request, "Script R executed for database {}".format(db.name))
def import_reports(self, request, queryset):
for db in queryset:
reports = read_data_from_file(db.ai_id)
self.message_user(
request,
"{} Data imported from the file for database {}".format(
reports, db.name))
def import_reports_forced(self, request, queryset):
for db in queryset:
reports = import_data_via_r_script(db)
self.message_user(
request,
"Old data deleted and {} Data imported from the file for database {}"
.format(reports, db.name))
import_reports_forced.short_description = 'Step 1: Import Indicator values via R script'
def generate_awp_code(self, request, queryset):
reports = 0
for db in queryset:
reports = generate_indicator_awp_code(db.ai_id)
self.message_user(request, "{} reports updated.".format(reports))
def calculate_sum_target(self, request, queryset):
reports = 0
for db in queryset:
reports = calculate_sum_target(db.id)
self.message_user(request, "{} indicators updated.".format(reports))
def link_indicators_data(self, request, queryset):
for db in queryset:
reports = link_indicators_data(db)
self.message_user(
request, "{} indicators linked for database {}".format(
reports, db.name))
link_indicators_data.short_description = 'Step 2: Link Indicators info to Indicator values'
def reset_indicators_values(self, request, queryset):
for db in queryset:
reports = reset_indicators_values(db.ai_id)
self.message_user(
request,
"{} indicators pre-calculated values removed and for database {} "
.format(reports, db.name))
def update_hpm_report(self, request, queryset):
reports = update_hpm_report()
self.message_user(request, "Update the HPM report")
update_hpm_report.short_description = 'Update HPM monthly report (3 in 1)'
def reset_hpm_indicators_values(self, request, queryset):
reports = reset_hpm_indicators_values()
self.message_user(
request,
"{} indicators pre-calculated HPM values removed and for database "
.format(reports))
reset_hpm_indicators_values.short_description = 'Step 0: Reset HPM indicators values'
def update_indicators_hpm(self, request, queryset):
reports = update_indicators_hpm_data()
self.message_user(
request,
"{} indicators pre-calculated HPM values removed and for database "
.format(reports))
update_indicators_hpm.short_description = 'Step 1: Update HPM indicators values'
def calculate_indicators_values(self, request, queryset):
for db in queryset:
reports = calculate_indicators_values(db)
self.message_user(
request,
"{} indicators values calculated for database {}".format(
reports, db.name))
calculate_indicators_values.short_description = 'Step 3: Reset and calculate monthly report, cumulative and status'
def calculate_indicators_cumulative_results(self, request, queryset):
for db in queryset:
reports = calculate_indicators_cumulative_results_1(db)
self.message_user(
request,
"{} indicators values cumulative calculated for database {}".
format(reports, db.name))
def calculate_indicators_cumulative_hpm(self, request, queryset):
reports = calculate_indicators_cumulative_hpm()
self.message_user(
request,
"{} indicators values cumulative HPM for database".format(reports))
calculate_indicators_cumulative_hpm.short_description = 'Step 2: Calculate HPM cumulative values'
def calculate_indicators_tags_hpm(self, request, queryset):
reports = calculate_indicators_tags_hpm()
self.message_user(
request,
"{} indicators values Tag HPM for database".format(reports))
calculate_indicators_tags_hpm.short_description = 'Step 3: Calculate HPM indicators percentages'
def calculate_indicators_tags(self, request, queryset):
reports = calculate_indicators_tags()
reports = calculate_indicators_monthly_tags()
self.message_user(request, "{} indicators values Tag".format(reports))
def calculate_indicators_status(self, request, queryset):
reports = 0
for db in queryset:
reports = calculate_indicators_status(db)
self.message_user(
request,
"{} indicators status calculated for database {}".format(
reports, db.name))
def update_indicator_name(self, request, queryset):
reports = 0
for db in queryset:
reports = update_indicator_data(ai_db=db,
ai_field_name='name',
field_name='name')
self.message_user(
request,
"{} indicators status calculated for database {}".format(
reports, db.name))
def update_indicator_list_header(self, request, queryset):
reports = 0
for db in queryset:
reports = update_indicator_data(ai_db=db,
ai_field_name='list_header',
field_name='listHeader')
self.message_user(
request,
"{} indicators status calculated for database {}".format(
reports, db.name))
formfield_overrides = {
JSONField: {
'widget': JSONEditorWidget(attrs={'initial': 'parsed'})
},
}
class Meta:
model = UserProfile
fields = '__all__'
widgets = {'ui_settings': JSONEditorWidget(mode='code')}
class Meta:
model = KanbanBoardUserFilterSetting
fields = '__all__'
widgets = {'settings': JSONEditorWidget(mode='code')}
