class UserAdmin(ModelView):
'''Interface admin de user'''
def format_user(self, request, user, *args):
return user.email.split('@')[0]
column_formatters = {'email': format_user}
column_list = ['admin', 'email']
column_labels = {'email': 'User login'}
column_searchable_list = ['email']
column_filters = [
'email',
'admin',
filters.FilterLike(
User.email, 'dominio', options=(
('gmail', 'Gmail'), ('uol', 'Uol')
)
),
]
can_edit = False
can_create = True
can_delete = True
# exemple of flask action
@action('toggle_admin', 'Toggle admin status', 'Are you sure?')
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids))
for user in users.all():
user.admin = not user.admin
db.session.commit()
flash('Success!', 'success')
class PostAdmin(sqla.ModelView):
column_display_pk = True
column_list = ['id', 'user', 'title', 'date', 'tags', 'background_color', 'created_at',]
column_editable_list = ['background_color', ]
column_default_sort = ('date', True)
column_sortable_list = [
'id',
'title',
'date',
('user', ('user.last_name', 'user.first_name')), # sort on multiple columns
]
column_labels = dict(title='Post Title') # Rename 'title' column in list view
column_searchable_list = [
'title',
'tags.name',
'user.first_name',
'user.last_name',
]
column_labels = {
'title': 'Title',
'tags.name': 'tags',
'user.first_name': 'user\'s first name',
'user.last_name': 'last name',
}
column_filters = [
'background_color',
'created_at',
'user',
'title',
'date',
'tags',
filters.FilterLike(Post.title, 'Fixed Title', options=(('test1', 'Test 1'), ('test2', 'Test 2'))),
]
can_export = True
export_max_rows = 1000
export_types = ['csv', 'xls']
# Pass arguments to WTForms. In this case, change label for text field to
# be 'Big Text' and add DataRequired() validator.
form_args = {
'text': dict(label='Big Text', validators=[validators.DataRequired()])
}
form_ajax_refs = {
'user': {
'fields': (User.first_name, User.last_name)
},
'tags': {
'fields': (Tag.name,),
'minimum_input_length': 0, # show suggestions, even before any user input
'placeholder': 'Please select',
'page_size': 5,
},
}
def __init__(self, session):
# Just call parent class with predefined model.
super(PostAdmin, self).__init__(Post, session)
class UserAdmin(ModelView):
"""Interface admin de user"""
# def format_user(self, request, user, *args):
# return user.email.split("@")[0]
# column_formatters = {
# "email": format_user
# igual a fç column_formatters
# }
column_formatters = {
"email": lambda s, r, u, *a: Markup(f'<b>{u.email.split("@")[0]}</b>')
}
column_list = ["email", "admin"]
can_edit = False
can_create = True
can_delete = True
column_labels = {"email": "User login"}
column_searchable_list = ["email"]
column_filters = [
"email",
"admin",
filters.FilterLike(
User.email, "dominio", options=(("gmail", "Gmail"), ("uol", "Uol"))
),
]
can_edit = False
can_create = True
can_delete = True
@action(
'toggle_admin',
'Toggle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids))
for user in users.all():
user.admin = not user.admin
db.session.commit()
flash(f"{users.count()} usuários alterados com sucesso!", "success")
@action("send_email", "Send email to all users", "Are you sure?")
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect para um form para escrever a mensagem do email
# 2) enviar o email
flash(f"{len(users)} emails enviados.", "success")
class UserAdmin(ModelView):
""" users admin interface """
column_formatters = {
"email": lambda s, r, u, *a: u.email.split("@")[0]
}
column_list = ["email", "admin"]
column_searchable_list = ["email"]
column_filters = [
"email",
"admin",
filters.FilterLike(
User.email,
"domain",
options=(("gmail", "Gmail"), ("hotmail", "Hotmail")
)
)
]
can_edit = False
can_create = True
can_delete = True
@action(
'toggle_admin',
'Toggle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f" {len(users)} Usuários alterados com sucesso!", "success")
@action(
'send_email',
'Send email to all users',
'Are you sure?'
)
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect to a form write the email context
# 2) send the email
flash(f" {len(users)} Usuários alterados com sucesso!", "success")
class UserAdmin(AdminView):
"""Interface admin de user"""
@event.listens_for(User.password, 'set', retval=True)
def hash_user_password(target, value, oldvalue, initiator):
if value != oldvalue:
return generate_password_hash(value)
return value
column_formatters = {
# "email": lambda s, r, u, *a: Markup(f'<b>{u.email.split("@")[0]}<b>')
}
column_list = ['email', 'name', 'admin']
column_searchable_list = ['email']
column_filters = [
filters.FilterLike(
User.email,
"Email",
options=(("gmail", "Gmail"), ("hotmail", "Hotmail"),
("outlook", "Outlook"))
),
'name',
'admin'
]
can_edit = False
@action(
'togle_admin',
'Togle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)}Usuário alterados com sucesso.", "success")
@action("send_email", "send Email to all users", "Are you sure?")
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect para um form para escrever a mensagem do email
# 2) enviar o email
flash(f"{len(users)} emails enviados com sucesso.", "success")
class UserView(sqla.ModelView):
column_exclude_list = ['username', 'password', 'registration_id']
column_searchable_list = ('first_name', 'last_name', 'username', 'email',
'role', 'services.name')
column_filters = ('services',
filters.FilterLike(User.role,
'Role',
options=(('Worker', 'Worker'),
('Customer', 'Customer'))))
form_excluded_columns = ['bookings', 'addresses', 'feedbacks']
form_choices = {'role': [('Worker', 'Worker'), ('Customer', 'Customer')]}
form_ajax_refs = {'services': {'fields': (Service.name, )}}
class PostAdmin(sqla.ModelView):
column_exclude_list = ['text']
column_default_sort = ('date', True)
column_sortable_list = [
'title',
'date',
('user', ('user.last_name', 'user.first_name')), # sort on multiple columns
]
column_labels = dict(title='Post Title') # Rename 'title' column in list view
column_searchable_list = [
'title',
User.first_name,
User.last_name,
'tags.name',
]
column_filters = [
'user',
'title',
'date',
'tags',
filters.FilterLike(Post.title, 'Fixed Title', options=(('test1', 'Test 1'), ('test2', 'Test 2'))),
]
# Pass arguments to WTForms. In this case, change label for text field to
# be 'Big Text' and add required() validator.
form_args = dict(
text=dict(label='Big Text', validators=[validators.required()])
)
form_ajax_refs = {
'user': {
'fields': (User.first_name, User.last_name)
},
'tags': {
'fields': (Tag.name,),
'minimum_input_length': 0, # show suggestions, even before any user input
'placeholder': 'Please select',
'page_size': 5,
},
}
def __init__(self, session):
# Just call parent class with predefined model.
super(PostAdmin, self).__init__(Post, session)
class UserAdmin(ModelView):
"""Interface admin """
column_formatters = {"email": format_user}
column_list = ["email", "admin"]
column_searchable_list = ["email"]
column_filters = [
"email",
"admin",
filters.FilterLike(
User.email,
"dominio",
options=(("gmail", "Gmail"), ("uol", "Uol"))
)]
#can_create = False
#can_edit = False
#can_delete = False
@action(
'toggle_admin',
'toggle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)} usuários alterados com sucesso!", "success")
@action(
'send_admin',
'send email to all users',
'Are you sure?'
)
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect para um form para escrever mensagem do email
# 2) enviar email
flash(f"{len(users)} emails enviados com sucesso!", "success")
class UserAdmin(ModelView):
"""Interface admin de user"""
column_formatters = {"email": lambda s, r, u, *a:Markup(f'<b>{u.email.split("@")[0]}</b>')}
column_list = ["email", "admin"]
can_edit = False
can_create = True
can_delete = True
column_searchable_list = ["email"]
column_filters = ["email",
"admin",
filters.FilterLike(
User.email,
"Dominios email",
options=(("gmail", "GMAIL"), ("uol", "UOL"))
)]
@action(
'toggle_admin',
'Toggle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)} Usuarios alterados com Sucesso", "success")
@action(
'send_email',
'send emails for all users?',
'Are yopu sure?'
)
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
flash(f"{len(users)} Usuarios alterados com Sucesso", "success")
class PostAdmin(sqla.ModelView):
# Visible columns in the list view
column_exclude_list = ["text"]
# List of columns that can be sorted. For 'user' column, use User.username as
# a column.
column_sortable_list = ("title", ("user", "user.username"), "date")
# Rename 'title' columns to 'Post Title' in list view
column_labels = dict(title="Post Title")
column_searchable_list = ("title", User.username, "tags.name")
column_filters = (
"user",
"title",
"date",
"tags",
filters.FilterLike(
Post.title,
"Fixed Title",
options=(("test1", "Test 1"), ("test2", "Test 2")),
),
)
# Pass arguments to WTForms. In this case, change label for text field to
# be 'Big Text' and add required() validator.
form_args = dict(
text=dict(label="Big Text", validators=[validators.required()]))
form_ajax_refs = {
"user": {
"fields": (User.username, User.email)
},
"tags": {
"fields": (Tag.name, )
},
}
def __init__(self, session):
# Just call parent class with predefined model.
super(PostAdmin, self).__init__(Post, session)
class UserAdmin(ModelView):
""" Interface admin de user """
column_formatters = {"email": format_user}
column_searchable_list = {"email"}
column_filters = [
"email",
"admin",
filters.FilterLike(
User.email,
"dominio",
options=(("gmail", "Gmail"), ("uol", "Uol"))
)
]
column_list = ["email", "admin"]
can_edit = False
can_create = True
can_delete = True
@action(
'toggle_admin',
'Toggle admin status',
'Are you sure?'
)
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)} usuários alterador com sucesso!!", "success")
@action(
'send_email',
'Send email to all users',
'Are you sure?'
)
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
flash(f"{len(users)} emails enviados", "success")
class UserAdmin(ModelView):
column_formatters = {"email": format_user}
column_list = ["email", "admin"]
column_searchable_list = ["email"]
column_filters = [
"email", "admin",
filters.FilterLike(User.email,
"Dominio",
options=(('gmail', 'Gmail'), ('ite', 'ITE')))
]
can_edit = False
can_create = True
can_delete = True
@action("Toggle_admin", "Toggle admin status", "Você tem certeza?")
def toggle_admin_status(self, ids):
for user in User.query.filter(User.id.in_(ids)).all():
user.admin = not user.admin
db.session.commit()
flash("Alteração realizada com sucesso!", "success")
class PostAdmin(sqla.ModelView):
# Visible columns in the list view
column_exclude_list = ['text']
# List of columns that can be sorted. For 'user' column, use User.username as
# a column.
column_sortable_list = ('title', ('user', 'user.username'), 'date')
# Rename 'title' columns to 'Post Title' in list view
column_labels = dict(title='Post Title')
column_searchable_list = ('title', User.username, 'tags.name')
column_filters = ('user', 'title', 'date', 'tags',
filters.FilterLike(Post.title,
'Fixed Title',
options=(('test1', 'Test 1'),
('test2', 'Test 2'))))
# Pass arguments to WTForms. In this case, change label for text field to
# be 'Big Text' and add required() validator.
form_args = dict(
text=dict(label='Big Text', validators=[validators.required()]))
form_ajax_refs = {
'user': {
'fields': (User.username, User.email)
},
'tags': {
'fields': (Tag.name, ),
'minimum_input_length': 0,
'placeholder': 'Please select',
'page_size': 5,
},
}
def __init__(self, session):
# Just call parent class with predefined model.
super(PostAdmin, self).__init__(Post, session)
class UserAdmin(ModelView):
"""interface admin de users"""
#column_formatters = {"email": format_user}
column_formatters = {
"email":
lambda s, r, u, *a: Markup(f'<b>{u.email.split("@")[0] + "@****"}</b>')
}
column_list = ["email", "admin"]
column_searchable_list = ["email"]
column_filters = [
"email", "admin",
filters.FilterLike(User.email,
"Dominio",
options=(("gmail", "Gmail"), ("uol", "Uol")))
]
can_edit = False
can_create = True
can_delete = True
@action('toggle_admin', 'Toggle admin status', 'Are you sure?')
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f" {len(users)} usuários alterados com sucesso!", "sucess")
@action('send_email', 'Send email to selected users', 'Are you sure?')
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect para um form para escrever a mensagem
# 2) enviar o email
flash(f" {len(users)} emails enviados com sucesso!", "sucess")
class UserAdmin(ModelView):
"""Interface admin de user"""
# def format_user(self, request, user, *args):
# return user.email.split("@")[0]
# column_formatters = {
# "email": format_user
# }
column_formatters = {
"email": lambda s, r, u, *a: Markup(f'<b>{u.email.split("@")[0]}</b>')
}
column_list = ["admin", "email"]
column_labels = {"email": "User login"}
column_searchable_list = ["email"]
column_filters = [
"email",
"admin",
filters.FilterLike(User.email,
"dominio",
options=(("gmail", "Gmail"), ("uol", "Uol"))),
]
can_edit = False
can_create = True
can_delete = True
@action("toggle_admin", "Toggle admin status", "Are you sure?")
def toggle_admin_status(self, ids):
for user in (users := User.query.filter(User.id.in_(ids)).all()):
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)} usuários alterados com sucesso!", "success")
class UserAdmin(ModelView):
"""Interface admin de user"""
column_formatters = {
# "email": format_user
# se usar o lambda, não precisa da função format_user
"email": lambda s, r, u, *a: Markup(f'<b>{u.email.split("@")[0]}</b>')
}
column_list = ['email', 'admin']
column_searchable_list = ['email']
column_filters = [
'email', 'admin',
filters.FilterLike(User.email,
"domínio",
options=(("gmail", "Gmail"), ("uol", "Uol")))
]
can_edit = False
can_create = True
can_deleste = True
@action('toggle_admin', 'Toggle admin status', 'Are you sure?')
def toggle_admin_status(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
for user in users:
user.admin = not user.admin
db.session.commit()
flash(f"{len(users)} usuários alterados com sucesso!", "success")
@action('send_email', 'Send email to all users', 'Are you sure?')
def send_email(self, ids):
users = User.query.filter(User.id.in_(ids)).all()
# 1) redirect para um form para escrever a mensagem do email
# 2) enviar o email
flash(f"{len(users)} emails enviados!", "success")
class AdminPostView(sqla.ModelView):
column_exclude_list = ['body']
column_sortable_list = (
'id',
'title',
('user', 'user.username'),
'timestamp',
)
column_list = (
'id',
'title',
'user.username',
'timestamp',
)
column_filters = ('user', 'title', 'timestamp',
filters.FilterLike(Post.title,
'Fixed Title',
options=(('test1', 'Test 1'),
('test2', 'Test 2'))))
form_args = dict(
text=dict(label='Big Text', validators=[validators.required()]))
form_ajax_refs = {'user': {'fields': (User.username, User.email)}}
class UserAdmin(sqla.ModelView):
def is_accessible(self):
return current_user.is_authenticated and current_user.is_admin
can_view_details = True # show a modal dialog with records details
action_disallowed_list = ['delete', ]
column_default_sort = ('createdon', True)
form_widget_args = {
'id': {
'readonly': True
},
}
column_list = [
'email',
'first_name',
'last_name',
'id_num',
'bank_name',
'bank_account_num',
'bank_account_name',
'role',
'admin',
'confirmed',
'createdon',
'farms',
'funded_farms'
]
form_columns = [
'email',
'bank_name',
'bank_account_num',
'bank_account_name',
'role',
'admin',
'confirmed',
'createdon',
'farms',
'funded_farms',
'password_hash'
]
column_searchable_list = [
'email',
'role',
'confirmed',
'bank_name',
'admin'
]
column_filters = [
'email',
'bank_name',
'bank_account_num',
'bank_account_name',
'admin',
'confirmed',
'createdon',
'farms',
'funded_farms',
filters.FilterLike(User.role, 'Role', options=(('0', 'Funder'), ('1',
'Farmner'))),
]
column_editable_list = ['confirmed', 'admin',]
# column details list
column_auto_select_related = True
# custom filter: each filter in the list is a filter operation (equals, not equals, etc)
# filters with the same name will appear as operations under the same filter
column_filters = [
'createdon',
'email',
'bank_name',
'role',
'admin',
]
class BookAdmin(sqla.ModelView):
"""The representation of the Book model in the Admin."""
form_choices = {
"language": AVAILABLE_LANGUAGES,
}
form_widget_args = {"id": {"readonly": True}}
action_disallowed_list = [
"delete",
]
can_view_details = True
column_display_pk = True
column_list = [
"id",
"author",
"title",
"publ_date",
"language",
"tags",
"record_created",
"record_modified",
]
column_details_list = [
"id",
"author",
"title",
"publ_date",
"description",
"language",
"tags",
"record_created",
"record_modified",
]
column_default_sort = ("publ_date", True)
column_editable_list = ["language"]
column_sortable_list = [
"id",
"title",
"publ_date",
(
"author",
("author.last_name", "author.first_name"),
),
]
column_searchable_list = [
"title",
"tags.name",
"author.first_name",
"author.last_name",
]
column_labels = {
"title": "Title",
"publ_date": "Publication Date",
"tags.name": "Tags",
"author.first_name": "Author's first name",
"author.last_name": "Last name",
}
column_filters = [
"author.last_name",
"record_created",
"record_modified",
"title",
"publ_date",
"tags",
filters.FilterLike(
Book.title,
"Common Title Words",
options=(("library", "Library"), ("service", "Service")),
),
]
can_export = True
export_max_rows = 1000
export_types = ["csv", "ods", "xlsx"]
create_modal = True
edit_modal = True
form_columns = [
"id",
"author",
"title",
"publ_date",
"description",
"language",
"tags",
"record_created",
"record_modified",
]
form_args = {
"description":
dict(label="Book Description", validators=[validators.DataRequired()])
}
form_widget_args = {"description": {"rows": 5}}
form_ajax_refs = {
"author": {
"fields": (Author.first_name, Author.last_name)
},
"tags": {
"fields": (Tag.name, ),
"minimum_input_length": 0,
"placeholder": "Please select",
"page_size": 5,
},
}
def __init__(self, session):
super(BookAdmin, self).__init__(Book, session)
