class FeatureAdmin(BaseAdmin):
Model = Feature
column_formatters = {
'feature_set': macro('render_fk_link'),
'created_by': macro('render_fk_link'),
'updated_by': macro('render_fk_link'),
}
class PredefinedScalerAdmin(BaseAdmin):
Model = PredefinedScaler
column_exclude_list = ('params', )
column_formatters = {
'created_by': macro('render_fk_link'),
'updated_by': macro('render_fk_link'),
}
class MyModelView(ModelView):
can_create = True
can_edit = True
can_delete = True
page_size = 50
form_overrides = {
'results_national': TextAreaField,
'results_provincial': TextAreaField
}
form_widget_args = {
'results_national': {
'rows': 15,
'class': "input-xxlarge"
},
'results_provincial': {
'rows': 15,
'class': "input-xxlarge"
},
}
list_template = 'admin/custom_list_template.html'
column_formatters = {
'results_national': macro('render_results'),
'results_provincial': macro('render_results')
}
column_filters = ['year', ]
def is_accessible(self):
return login.current_user.is_authenticated()
class ModelAdmin(BaseAdmin):
Model = Model
column_searchable_list = ('name', )
form_excluded_columns = ('trainer', 'weights', 'weight_categories')
column_formatters = {
'features_set': macro('render_fk_link'),
'test_import_handler': macro('render_fk_link'),
'train_import_handler': macro('render_fk_link'),
'status': macro('status_with_error'),
'classifier': classifier_type_formatter
}
column_list = [
'id', 'name', 'status', 'classifier', 'features_set', 'feature_count',
'target_variable', 'memory_usage', 'training_time',
'test_import_handler', 'train_import_handler'
]
column_sortable_list = (
('id', Model.id),
('name', Model.name),
('target_variable', Model.target_variable),
('memory_usage', Model.memory_usage),
('training_time', Model.training_time),
('status', Model.status),
('feature_count', Model.feature_count),
)
column_filters = ('status', )
class NamedFeatureTypeAdmin(BaseAdmin):
Model = NamedFeatureType
column_exclude_list = ('params', )
column_formatters = {
'created_by': macro('render_fk_link'),
'updated_by': macro('render_fk_link'),
}
class VerificationExampleAdmin(BaseAdmin):
Model = VerificationExample
MIX_METADATA = False
column_formatters = {
'example': macro('render_fk_link'),
'verification': macro('render_fk_link'),
}
column_list = ['id', 'example', 'verification']
class SqoopAdmin(BaseAdmin):
MIX_METADATA = False
Model = XmlSqoop
column_list = ['id', 'entity', 'target', 'table', 'datasource']
column_formatters = {
'entity': macro('render_fk_link'),
'datasource': macro('render_fk_link')
}
def __init__(self, *args, **kwargs):
if self.MIX_METADATA:
if self.column_list:
self.column_list.append('created')
self.column_list.append('updated')
self.column_formatters['created'] = macro('render_created')
self.column_formatters['updated'] = macro('render_updated')
self.column_filters = list(self.column_filters or [])
self.column_filters.append('created_on')
super(BaseAdmin, self).__init__(self.Model, app.sql_db.session, *args,
**kwargs)
class TestExampleAdmin(BaseAdmin):
Model = TestExample
column_formatters = {
'test_result': macro('render_fk_link'),
'model': macro('render_fk_link')}
column_list = ['id', 'name', 'example_id', 'label', 'pred_label',
'prob', 'model', 'test_result']
column_sortable_list = (
('example_id', TestExample.example_id),
('label', TestExample.label),
('pred_label', TestExample.pred_label),
)
class ServerModelVerificationAdmin(BaseAdmin):
Model = ServerModelVerification
column_formatters = {
'server': macro('render_fk_link'),
'model': macro('render_fk_link'),
'import_handler': macro('render_fk_link'),
'test_result': macro('render_fk_link'),
}
column_filters = ('status', )
column_list = [
'id', 'server', 'model', 'import_handler',
'test_result', 'status']
class TestResultAdmin(BaseAdmin):
Model = TestResult
form_excluded_columns = ('examples', )
column_formatters = {
'status': macro('status_with_error'),
'model': macro('render_fk_link')}
column_list = ['id', 'name', 'status', 'model', 'accuracy', 'parameters',
'examples_count', 'examples_size', 'classes_set',
'memory_usage']
column_sortable_list = (
('status', TestResult.status),
('examples_count', TestResult.examples_count),
('accuracy', TestResult.accuracy),
)
class WeightsCategoryAdmin(BaseAdmin): # TODO: tree?
Model = WeightsCategory
MIX_METADATA = False
column_formatters = {'model': macro('render_fk_link')}
column_list = ['id', 'name', 'model', 'short_name', 'parent']
column_sortable_list = (('name', WeightsCategory.name),
('model', WeightsCategory.model))
class ClassifierGridParamsAdmin(BaseAdmin):
Model = ClassifierGridParams
column_formatters = {'model': macro('render_fk_link')}
column_list = [
'id', 'model', 'train_dataset', 'scoring', 'status', 'parameters',
'parameters_grid'
]
class UserView(CustomModelView):
column_list = ('email', 'active', 'username', 'first_name', 'last_name',
'user_operations')
column_filters = ('id', 'email', 'active', 'username', 'first_name',
'last_name')
column_formatters = dict(user_operations=macro('user_operations'))
list_template = 'admin/user/list.html'
class EntityAdmin(BaseAdmin):
MIX_METADATA = False
Model = XmlEntity
column_list = ['id', 'name', 'datasource',
'datasource_name', 'entity', 'import_handler']
column_formatters = {
'datasource': macro('render_fk_link')}
class ReportView(CustomView):
"""
Report view.
"""
can_create = False
can_edit = False
column_searchable_list = ('version', 'filename')
column_filters = ('version', 'filename', 'latest')
column_formatters = dict(changes=macro('render_changes'))
@action('rollback', 'Rollback',
'Are you sure you want to rollback the configuration ?')
def rollback(self):
"""
This is not used.
:return:
"""
if session.get('ipaddr') is None:
flash('APIC Credentials have not been entered', 'error')
return redirect(url_for('snapshotsadmin.index_view'))
return redirect(url_for('snapshotsadmin.index_view'))
@action('view', 'View')
def view(*args, **kwargs):
"""
:param args:
:param kwargs:
:return:
"""
return redirect(url_for('fileview.index'))
class MediumView(MyModelView):
column_list = (
'name',
'domain',
'medium_type',
'medium_group',
'parent_org',
'country',
)
column_labels = dict(medium_type='Publication Type', )
column_searchable_list = ('name', 'parent_org')
column_default_sort = 'name'
column_formatters = dict(medium_type=macro('render_medium_type'), )
column_sortable_list = (
('name', Medium.name),
'domain',
'medium_type',
'medium_group',
('country', Country.name),
)
column_filters = ['country.name']
choices = []
for choice in [
"online", "print - daily", "print - weekly", "radio", "television",
"other"
]:
choices.append((choice, choice.title()))
form_overrides = dict(medium_type=SelectField)
form_args = dict(
# Pass the choices to the `SelectField`
medium_type=dict(choices=choices),
domain=dict(filters=[lambda x: x or None]))
class PredictAdmin(BaseAdmin):
MIX_METADATA = False
Model = Predict
column_list = ['id', ]
column_formatters = {
'xml_import_handler': macro('render_fk_link')
}
class SnapshotsAdmin(CustomView):
can_create = False
can_edit = False
column_searchable_list = ('version', 'filename')
column_filters = ('version', 'filename', 'latest')
column_formatters = dict(changes=macro('render_changes'))
# @action('rollback', 'Rollback',
# 'Are you sure you want to rollback the configuration ?')
# def rollback(*args, **kwargs):
# if session.get('ipaddr') is None:
# flash('APIC Credentials have not been entered', 'error')
# return redirect(url_for('snapshotsadmin.index_view'))
# login_args = APICArgs(session.get('ipaddr'),
# session.get('username'),
# session.get('secure'),
# session.get('password'))
# try:
# resp = cdb.login(login_args)
# if resp.ok is not True:
# flash('Unable to login to the APIC', 'error')
# return redirect(url_for('snapshotsadmin.index_view'))
# except Timeout:
# flash('Connection timeout when trying to reach the APIC', 'error')
# return redirect(url_for('snapshotsadmin.index_view'))
#
# rollback_files = {}
# for file_id in args[1]:
# file_obj = Snapshots.query.get(file_id)
# version = file_obj.version
# if version not in rollback_files:
# rollback_files[version] = []
# rollback_files[version].append(file_obj.filename)
# for version in rollback_files:
# cdb.rollback(version, rollback_files[version])
# flash(('APIC has been successfully rolled back to the specified'
# ' version'), 'success')
# return redirect(url_for('snapshotsadmin.index_view'))
@action('view_diffs', 'View Diffs')
def view_diffs(*args, **kwargs):
if len(args[1]) != 2:
if len(args[1]) > 2:
flash('Please select only 2 snapshots to view diffs')
else:
flash('Please select 2 snapshots to view diffs')
else:
session['diff_files'] = args[1]
return redirect(url_for('diffview.index'))
@action('view', 'View')
def view(*args, **kwargs):
for arg in args[1]:
obj = Snapshots.query.get(arg)
session['viewfiles'] = args[1]
return redirect(url_for('fileview.index'))
class WeightAdmin(BaseAdmin):
Model = Weight
MIX_METADATA = False
column_formatters = {'model': macro('render_fk_link')}
column_list = [
'id', 'name', 'model', 'short_name', 'parent', 'value', 'is_positive',
'css_class'
]
column_sortable_list = (('name', Weight.name), ('model', Weight.model))
column_filters = ('name', 'is_positive', 'css_class', 'value')
class AgentView(MyModelView):
list_template = 'admin/custom_list_template.html'
column_searchable_list = ('name', )
form_create_rules = (
'name',
'type',
'url',
'location',
)
form_edit_rules = form_create_rules
column_formatters = dict(
location=macro('render_location'),
url=macro('render_url'),
)
form_overrides = dict(location=SelectField, type=SelectField)
form_args = {
# Pass the choices to the `SelectField`
"location":{
"choices": [
("", "Unknown"),
("1", "National Assembly (NA)"),
("2", "National Council of Provinces (NCOP)"),
("3", "President's Office"),
("4", "Joint consideration (NA+NCOP)"),
]
},
"type":{
"choices": [
("committee", "Committee"),
("minister", "Minister"),
("president", "The President"),
("house", "House of Parliament"),
]
},
}
form_widget_args = {
'name': {
'class': 'input-xxlarge'
},
'url': {
'class': 'input-xxlarge'
}
}
class EntityView(MyModelView):
can_create = False
can_edit = False
column_list = ('name', 'group', 'created_at', 'updated_at')
column_labels = dict(
created_at='Date Created',
group='Type',
updated_at='Last Updated',
)
column_formatters = dict(name=macro('render_entity_name'), )
column_searchable_list = ('name', 'group')
class RelatedDocView(MyModelView):
list_template = 'admin/custom_list_template.html'
form_create_rules = ('type', 'bills', 'title', 'url')
form_edit_rules = form_create_rules
column_list = ('type', 'bills', 'title', 'url')
column_formatters = dict(
url=macro('render_url'),
bills=macro('render_bills'),
)
form_overrides = dict(type=SelectField,)
form_args = {
# Pass the choices to the `SelectField`
"type":{
"choices": related_doc_choices
},
}
form_widget_args = {
'title': {
'class': 'input-xxlarge'
},
'url': {
'class': 'input-xxlarge'
}
}
def get_query(self):
"""
Add filter to return only non-deleted records.
"""
query = self.session.query(self.model) \
.filter(self.model.is_deleted==False) \
.filter(Entry.type.in_(related_doc_types))
if request.args.get('bill_id'):
try:
bill = Bill.query.get(request.args['bill_id'])
self._template_args['filtered_bill'] = bill
query = query.filter(Entry.bills.any(bill_id=request.args['bill_id']))
except Exception, e:
pass
return query
class DocumentView(MyModelView):
can_create = False
can_edit = False
column_list = ('published_at', 'medium', 'title', 'summary', 'updated_at')
column_labels = dict(
published_at='Date Published',
medium='Source',
updated_at='Last Updated',
)
column_sortable_list = ('published_at', ('medium', Medium.name), 'title',
'summary', 'updated_at')
column_formatters = dict(medium=macro('render_medium'),
published_at=macro('render_date'),
title=macro('render_document_title'),
updated_at=macro('render_date'))
form_overrides = dict(
summary=TextAreaField,
text=TextAreaField,
)
column_searchable_list = (
'title',
'summary',
)
class ServerAdmin(BaseAdmin):
Model = Server
column_list = ['id', 'name', 'ip', 'folder', 'is_default', 'memory_mb',
'type', 'logs_url']
column_sortable_list = (
('ip', Server.ip),
('folder', Server.folder),
('is_default', Server.is_default),
('memory_mb', Server.memory_mb),
('type', Server.type)
)
form_args = dict(memory_mb=dict(label='Memory Size (MB)'))
column_formatters = {
'logs_url': macro('render_link')
}
class ColorAdmin(ModelView):
# Force specific template
list_template = 'color_list.html'
create_template = 'color_form.html'
edit_template = 'color_form.html'
# Customize list view to call 'color' macro for value column
list_formatters = dict(value=template.macro('color'))
# Use select field for value column
form_overrides = dict(value=SelectField)
form_args = dict(value=dict(choices=[
('#000000', 'Black'),
('#ffffff', 'White'),
('#ff0000', 'Red'),
('#00ff00', 'Green'),
('#0000ff', 'Blue'),
]))
class CommitteeView(MyModelView):
can_delete = False
column_list = ('name', 'house', 'ad_hoc', 'memberships')
column_labels = {
'memberships': 'Members',
'minister': 'Associated Minister',
}
column_sortable_list = (
'name',
('house', 'house.name'),
'ad_hoc',
)
column_default_sort = (Committee.name, False)
column_searchable_list = ('name', )
column_formatters = dict(memberships=macro('render_membership_count'), )
form_columns = (
'name',
'ad_hoc',
'premium',
'house',
'minister',
'about',
'contact_details',
'memberships',
)
form_widget_args = {
'about': {
'class': 'ckeditor'
},
'contact_details': {
'class': 'ckeditor'
},
}
form_args = {
'memberships': {
'widget': widgets.InlineMembershipsWidget()
},
}
inline_models = (Membership, )
class ScriptAdmin(BaseAdmin):
MIX_METADATA = False
Model = XmlScript
column_formatters = {'import_handler': macro('render_fk_link'), }
column_list = ['id', 'type', 'import_handler']
class InputParameterAdmin(BaseAdmin):
MIX_METADATA = False
Model = XmlInputParameter
column_formatters = {'import_handler': macro('render_fk_link'), }
column_list = ['id', 'name', 'type', 'regex', 'format', 'import_handler']
column_filters = ('name', )
class UserAdmin(BaseAdmin):
Model = User
MIX_METADATA = False
column_searchable_list = ('name', 'uid')
column_formatters = {'odesk_url': macro('render_link')}
column_exclude_list = ('auth_token', 'portrait_32_img')
