desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Test Master detail view'
| def test_master_detail_view(self):
| client = self.app.test_client()
self.login(client, DEFAULT_ADMIN_USER, DEFAULT_ADMIN_PASSWORD)
self.insert_data2()
rv = client.get('/model1masterview/list/')
eq_(rv.status_code, 200)
rv = client.get('/model1masterview/list/1')
eq_(rv.status_code, 200)
rv = client.get('/model1masterchartv... |
'Testing the api/read endpoint'
| def test_api_read(self):
| client = self.app.test_client()
self.login(client, DEFAULT_ADMIN_USER, DEFAULT_ADMIN_PASSWORD)
self.insert_data()
rv = client.get('/model1formattedview/api/read')
eq_(rv.status_code, 200)
data = json.loads(rv.data.decode('utf-8'))
assert ('result' in data)
assert ('pks' in data)
asse... |
'Testing the api/create endpoint'
| def test_api_create(self):
| client = self.app.test_client()
self.login(client, DEFAULT_ADMIN_USER, DEFAULT_ADMIN_PASSWORD)
rv = client.post('/model1view/api/create', data=dict(field_string='zzz'), follow_redirects=True)
eq_(rv.status_code, 200)
objs = self.db.session.query(Model1).all()
eq_(len(objs), 1)
|
'Validate that the api update endpoint updates [only] the fields in
POST data'
| def test_api_update(self):
| client = self.app.test_client()
self.login(client, DEFAULT_ADMIN_USER, DEFAULT_ADMIN_PASSWORD)
self.insert_data()
item = self.db.session.query(Model1).filter_by(id=1).one()
field_integer_before = item.field_integer
rv = client.put('/model1view/api/update/1', data=dict(field_string='zzz'), follow... |
'create dict labels based on form'
| def __call__(self, **kwargs):
| ' create dict of form widgets '
' create dict of possible filters '
' create list of active filters '
label_columns = {}
form_fields = {}
search_filters = {}
dict_filters = self.filters.get_search_filters()
for col in self.template_ar... |
'SecurityManager contructor
param appbuilder:
F.A.B AppBuilder main object'
| def __init__(self, appbuilder):
| super(SecurityManager, self).__init__(appbuilder)
user_datamodel = MongoEngineInterface(self.user_model)
if (self.auth_type == c.AUTH_DB):
self.userdbmodelview.datamodel = user_datamodel
elif (self.auth_type == c.AUTH_LDAP):
self.userldapmodelview.datamodel = user_datamodel
elif (sel... |
'Generic function to create user'
| def add_user(self, username, first_name, last_name, email, role, password='', hashed_password=''):
| try:
user = self.user_model()
user.first_name = first_name
user.last_name = last_name
user.username = username
user.email = email
user.active = True
user.roles.append(role)
if hashed_password:
user.password = hashed_password
else:
... |
'Finds and returns a Permission by name'
| def find_permission(self, name):
| return self.permission_model.objects(name=name).first()
|
'Adds a permission to the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def add_permission(self, name):
| perm = self.find_permission(name)
if (perm is None):
try:
perm = self.permission_model(name=name)
perm.save()
return perm
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_ADD_PERMISSION.format(str(e)))
return perm
|
'Deletes a permission from the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def del_permission(self, name):
| perm = self.find_permission(name)
if perm:
try:
perm.delete()
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_PERMISSION.format(str(e)))
|
'Finds and returns a ViewMenu by name'
| def find_view_menu(self, name):
| return self.viewmenu_model.objects(name=name).first()
|
'Adds a view or menu to the backend, model view_menu
param name:
name of the view menu to add'
| def add_view_menu(self, name):
| view_menu = self.find_view_menu(name)
if (view_menu is None):
try:
view_menu = self.viewmenu_model(name=name)
view_menu.save()
return view_menu
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_ADD_VIEWMENU.format(str(e)))
return view_menu
|
'Deletes a ViewMenu from the backend
:param name:
name of the ViewMenu'
| def del_view_menu(self, name):
| obj = self.find_view_menu(name)
if obj:
try:
obj.delete()
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_PERMISSION.format(str(e)))
|
'Finds and returns a PermissionView by names'
| def find_permission_view_menu(self, permission_name, view_menu_name):
| permission = self.find_permission(permission_name)
view_menu = self.find_view_menu(view_menu_name)
return self.permissionview_model.objects(permission=permission, view_menu=view_menu).first()
|
'Finds all permissions from ViewMenu, returns list of PermissionView
:param view_menu: ViewMenu object
:return: list of PermissionView objects'
| def find_permissions_view_menu(self, view_menu):
| return self.permissionview_model.objects(view_menu=view_menu)
|
'Adds a permission on a view or menu to the backend
:param permission_name:
name of the permission to add: \'can_add\',\'can_edit\' etc...
:param view_menu_name:
name of the view menu to add'
| def add_permission_view_menu(self, permission_name, view_menu_name):
| vm = self.add_view_menu(view_menu_name)
perm = self.add_permission(permission_name)
pv = self.permissionview_model()
(pv.view_menu, pv.permission) = (vm, perm)
try:
pv.save()
log.info(c.LOGMSG_INF_SEC_ADD_PERMVIEW.format(str(pv)))
return pv
except Exception as e:
... |
'Add permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def add_permission_role(self, role, perm_view):
| if (perm_view not in role.permissions):
try:
role.permissions.append(perm_view)
role.save()
log.info(c.LOGMSG_INF_SEC_ADD_PERMROLE.format(str(perm_view), role.name))
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_ADD_PERMROLE.format(str(e)))
|
'Remove permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def del_permission_role(self, role, perm_view):
| if (perm_view in role.permissions):
try:
role.permissions.remove(perm_view)
role.save()
log.info(c.LOGMSG_INF_SEC_DEL_PERMROLE.format(str(perm_view), role.name))
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_PERMROLE.format(str(e)))
|
'Adds a permission on a view menu to the backend
:param base_permissions:
list of permissions from view (all exposed methods): \'can_add\',\'can_edit\' etc...
:param view_menu:
name of the view or menu to add'
| def add_permissions_view(self, base_permissions, view_menu):
| raise NotImplementedError
|
'Adds menu_access to menu on permission_view_menu
:param view_menu_name:
The menu name'
| def add_permissions_menu(self, view_menu_name):
| raise NotImplementedError
|
'Generic function to create the security views'
| def register_views(self):
| raise NotImplementedError
|
'Check if view has public permissions
:param permission_name:
the permission: can_show, can_edit...
:param view_name:
the name of the class view (child of BaseView)'
| def is_item_public(self, permission_name, view_name):
| raise NotImplementedError
|
'Check if current user or public has access to view or menu'
| def has_access(self, permission_name, view_name):
| raise NotImplementedError
|
'Decorator function to be the OAuth user info getter
for all the providers, receives provider and response
return a dict with the information returned from the provider.
The returned user info dict should have it\'s keys with the same
name as the User Model.
Use it like this an example for GitHub ::
@appbuilder.sm.oaut... | def oauth_user_info_getter(self, f):
| def wraps(provider, response=None):
ret = f(self, provider, response=response)
if (not (type(ret) == dict)):
log.error('OAuth user info decorated function did not returned a dict, but: {0}'.format(type(ret)))
return {}
return ret
s... |
'Returns the token_key name for the oauth provider
if none is configured defaults to oauth_token
this is configured using OAUTH_PROVIDERS and token_key key.'
| def get_oauth_token_key_name(self, provider):
| for _provider in self.oauth_providers:
if (_provider['name'] == provider):
return _provider.get('token_key', 'oauth_token')
|
'Returns the token_secret name for the oauth provider
if none is configured defaults to oauth_secret
this is configured using OAUTH_PROVIDERS and token_secret'
| def get_oauth_token_secret_name(self, provider):
| for _provider in self.oauth_providers:
if (_provider['name'] == provider):
return _provider.get('token_secret', 'oauth_token_secret')
|
'Set the current session with OAuth user secrets'
| def set_oauth_session(self, provider, oauth_response):
| token_key = self.appbuilder.sm.get_oauth_token_key_name(provider)
token_secret = self.appbuilder.sm.get_oauth_token_secret_name(provider)
session['oauth'] = (oauth_response[token_key], oauth_response.get(token_secret, ''))
session['oauth_provider'] = provider
|
'Since there are different OAuth API\'s with different ways to
retrieve user info'
| def get_oauth_user_info(self, provider, resp=None):
| if ((provider == 'github') or (provider == 'githublocal')):
me = self.appbuilder.sm.oauth_remotes[provider].get('user')
log.debug('User info from Github: {0}'.format(me.data))
return {'username': ('github_' + me.data.get('login'))}
if (provider == 'twitter'):
me = sel... |
'Setups the DB, creates admin and public roles if they don\'t exist.'
| def create_db(self):
| self.add_role(self.auth_role_admin)
self.add_role(self.auth_role_public)
if (self.count_users() == 0):
log.warning(LOGMSG_WAR_SEC_NO_USER)
|
'Change/Reset a user\'s password for authdb.
Password will be hashed and saved.
:param userid:
the user.id to reset the password
:param password:
The clear text password to reset and save hashed on the db'
| def reset_password(self, userid, password):
| user = self.get_user_by_id(userid)
user.password = generate_password_hash(password)
self.update_user(user)
|
'Update authentication successful to user.
:param user:
The authenticated user model'
| def update_user_auth_stat(self, user, success=True):
| if (not user.login_count):
user.login_count = 0
if (not user.fail_login_count):
user.fail_login_count = 0
if success:
user.login_count += 1
user.fail_login_count = 0
else:
user.fail_login_count += 1
user.last_login = datetime.datetime.now()
self.update_use... |
'Method for authenticating user, auth db style
:param username:
The username or registered email address
:param password:
The password, will be tested against hashed password on db'
| def auth_user_db(self, username, password):
| if ((username is None) or (username == '')):
return None
user = self.find_user(username=username)
if (user is None):
user = self.find_user(email=username)
if ((user is None) or (not user.is_active())):
log.info(LOGMSG_WAR_SEC_LOGIN_FAILED.format(username))
return None
... |
'Searches LDAP for user, assumes ldap_search is set.
:param ldap: The ldap module reference
:param con: The ldap connection
:param username: username to match with auth_ldap_uid_field
:return: ldap object array'
| def _search_ldap(self, ldap, con, username):
| if self.auth_ldap_append_domain:
username = ((username + '@') + self.auth_ldap_append_domain)
filter_str = ('%s=%s' % (self.auth_ldap_uid_field, username))
user = con.search_s(self.auth_ldap_search, ldap.SCOPE_SUBTREE, filter_str, [self.auth_ldap_firstname_field, self.auth_ldap_lastname_field, self.... |
'Private to bind/Authenticate a user.
If AUTH_LDAP_BIND_USER exists then it will bind first with it,
next will search the LDAP server using the username with UID
and try to bind to it (OpenLDAP).
If AUTH_LDAP_BIND_USER does not exit, will bind with username/password'
| def _bind_ldap(self, ldap, con, username, password):
| try:
indirect_user = self.auth_ldap_bind_user
if indirect_user:
indirect_password = self.auth_ldap_bind_password
log.debug('LDAP indirect bind with: {0}'.format(indirect_user))
con.bind_s(indirect_user, indirect_password)
log.debug('LDAP ... |
'Method for authenticating user, auth LDAP style.
depends on ldap module that is not mandatory requirement
for F.A.B.
:param username:
The username
:param password:
The password'
| def auth_user_ldap(self, username, password):
| if ((username is None) or (username == '')):
return None
user = self.find_user(username=username)
if ((user is not None) and (not user.is_active())):
return None
else:
try:
import ldap
except:
raise Exception('No ldap library for python... |
'OpenID user Authentication
:type self: User model'
| def auth_user_oid(self, email):
| user = self.find_user(email=email)
if ((user is None) or (not user.is_active())):
log.info(LOGMSG_WAR_SEC_LOGIN_FAILED.format(email))
return None
else:
self.update_user_auth_stat(user)
return user
|
'REMOTE_USER user Authentication
:type self: User model'
| def auth_user_remote_user(self, username):
| user = self.find_user(username=username)
if ((user is None) or (not user.is_active())):
log.info(LOGMSG_WAR_SEC_LOGIN_FAILED.format(username))
return None
else:
self.update_user_auth_stat(user)
return user
|
'OAuth user Authentication
:userinfo: dict with user information the keys have the same name
as User model columns.'
| def auth_user_oauth(self, userinfo):
| if ('username' in userinfo):
user = self.find_user(username=userinfo['username'])
elif ('email' in userinfo):
user = self.find_user(email=userinfo['email'])
else:
log.error('User info does not have username or email {0}'.format(userinfo))
return None
... |
'Check if view has public permissions
:param permission_name:
the permission: can_show, can_edit...
:param view_name:
the name of the class view (child of BaseView)'
| def is_item_public(self, permission_name, view_name):
| permissions = self.get_public_permissions()
if permissions:
for i in permissions:
if ((view_name == i.view_menu.name) and (permission_name == i.permission.name)):
return True
return False
else:
return False
|
'Check if current user or public has access to view or menu'
| def has_access(self, permission_name, view_name):
| if current_user.is_authenticated():
return self._has_view_access(g.user, permission_name, view_name)
else:
return self.is_item_public(permission_name, view_name)
|
'Adds a permission on a view menu to the backend
:param base_permissions:
list of permissions from view (all exposed methods): \'can_add\',\'can_edit\' etc...
:param view_menu:
name of the view or menu to add'
| def add_permissions_view(self, base_permissions, view_menu):
| view_menu_db = self.add_view_menu(view_menu)
perm_views = self.find_permissions_view_menu(view_menu_db)
if (not perm_views):
for permission in base_permissions:
pv = self.add_permission_view_menu(permission, view_menu)
role_admin = self.find_role(self.auth_role_admin)
... |
'Adds menu_access to menu on permission_view_menu
:param view_menu_name:
The menu name'
| def add_permissions_menu(self, view_menu_name):
| self.add_view_menu(view_menu_name)
pv = self.find_permission_view_menu('menu_access', view_menu_name)
if (not pv):
pv = self.add_permission_view_menu('menu_access', view_menu_name)
role_admin = self.find_role(self.auth_role_admin)
self.add_permission_role(role_admin, pv)
|
'Will cleanup all unused permissions from the database
:param baseviews: A list of BaseViews class
:param menus: Menu class'
| def security_cleanup(self, baseviews, menus):
| viewsmenus = self.get_all_view_menu()
roles = self.get_all_roles()
for viewmenu in viewsmenus:
found = False
for baseview in baseviews:
if (viewmenu.name == baseview.__class__.__name__):
found = True
break
if menus.find(viewmenu.name):
... |
'Generic function to return user registration'
| def find_register_user(self, registration_hash):
| raise NotImplementedError
|
'Generic function to add user registration'
| def add_register_user(self, username, first_name, last_name, email, password='', hashed_password=''):
| raise NotImplementedError
|
'Generic function to delete user registration'
| def del_register_user(self, register_user):
| raise NotImplementedError
|
'Generic function to return user by it\'s id (pk)'
| def get_user_by_id(self, pk):
| raise NotImplementedError
|
'Generic function find a user by it\'s username or email'
| def find_user(self, username=None, email=None):
| raise NotImplementedError
|
'Generic function that returns all exsiting users'
| def get_all_users(self):
| raise NotImplementedError
|
'Generic function to create user'
| def add_user(self, username, first_name, last_name, email, role, password=''):
| raise NotImplementedError
|
'Generic function to update user
:param user: User model to update to database'
| def update_user(self, user):
| raise NotImplementedError
|
'Generic function to count the existing users'
| def count_users(self):
| raise NotImplementedError
|
'returns all permissions from public role'
| def get_public_permissions(self):
| raise NotImplementedError
|
'Finds and returns a Permission by name'
| def find_permission(self, name):
| raise NotImplementedError
|
'Adds a permission to the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def add_permission(self, name):
| raise NotImplementedError
|
'Deletes a permission from the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def del_permission(self, name):
| raise NotImplementedError
|
'Finds and returns a ViewMenu by name'
| def find_view_menu(self, name):
| raise NotImplementedError
|
'Adds a view or menu to the backend, model view_menu
param name:
name of the view menu to add'
| def add_view_menu(self, name):
| raise NotImplementedError
|
'Deletes a ViewMenu from the backend
:param name:
name of the ViewMenu'
| def del_view_menu(self, name):
| raise NotImplementedError
|
'Finds and returns a PermissionView by names'
| def find_permission_view_menu(self, permission_name, view_menu_name):
| raise NotImplementedError
|
'Finds all permissions from ViewMenu, returns list of PermissionView
:param view_menu: ViewMenu object
:return: list of PermissionView objects'
| def find_permissions_view_menu(self, view_menu):
| raise NotImplementedError
|
'Adds a permission on a view or menu to the backend
:param permission_name:
name of the permission to add: \'can_add\',\'can_edit\' etc...
:param view_menu_name:
name of the view menu to add'
| def add_permission_view_menu(self, permission_name, view_menu_name):
| raise NotImplementedError
|
'Add permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def add_permission_role(self, role, perm_view):
| raise NotImplementedError
|
'Remove permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def del_permission_role(self, role, perm_view):
| raise NotImplementedError
|
'SecurityManager contructor
param appbuilder:
F.A.B AppBuilder main object'
| def __init__(self, appbuilder):
| super(SecurityManager, self).__init__(appbuilder)
user_datamodel = SQLAInterface(self.user_model)
if (self.auth_type == c.AUTH_DB):
self.userdbmodelview.datamodel = user_datamodel
elif (self.auth_type == c.AUTH_LDAP):
self.userldapmodelview.datamodel = user_datamodel
elif (self.auth_... |
'Add a registration request for the user.
:rtype : RegisterUser'
| def add_register_user(self, username, first_name, last_name, email, password='', hashed_password=''):
| register_user = self.registeruser_model()
register_user.username = username
register_user.email = email
register_user.first_name = first_name
register_user.last_name = last_name
if hashed_password:
register_user.password = hashed_password
else:
register_user.password = genera... |
'Deletes registration object from database
:param register_user: RegisterUser object to delete'
| def del_register_user(self, register_user):
| try:
self.get_session.delete(register_user)
self.get_session.commit()
return True
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_REGISTER_USER.format(str(e)))
self.get_session.rollback()
return False
|
'Finds user by username or email'
| def find_user(self, username=None, email=None):
| if username:
return self.get_session.query(self.user_model).filter((func.lower(self.user_model.username) == func.lower(username))).first()
elif email:
return self.get_session.query(self.user_model).filter_by(email=email).first()
|
'Generic function to create user'
| def add_user(self, username, first_name, last_name, email, role, password='', hashed_password=''):
| try:
user = self.user_model()
user.first_name = first_name
user.last_name = last_name
user.username = username
user.email = email
user.active = True
user.roles.append(role)
if hashed_password:
user.password = hashed_password
else:
... |
'Finds and returns a Permission by name'
| def find_permission(self, name):
| return self.get_session.query(self.permission_model).filter_by(name=name).first()
|
'Adds a permission to the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def add_permission(self, name):
| perm = self.find_permission(name)
if (perm is None):
try:
perm = self.permission_model()
perm.name = name
self.get_session.add(perm)
self.get_session.commit()
return perm
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_ADD... |
'Deletes a permission from the backend, model permission
:param name:
name of the permission: \'can_add\',\'can_edit\' etc...'
| def del_permission(self, name):
| perm = self.find_permission(name)
if perm:
try:
self.get_session.delete(perm)
self.get_session.commit()
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_PERMISSION.format(str(e)))
self.get_session.rollback()
|
'Finds and returns a ViewMenu by name'
| def find_view_menu(self, name):
| return self.get_session.query(self.viewmenu_model).filter_by(name=name).first()
|
'Adds a view or menu to the backend, model view_menu
param name:
name of the view menu to add'
| def add_view_menu(self, name):
| view_menu = self.find_view_menu(name)
if (view_menu is None):
try:
view_menu = self.viewmenu_model()
view_menu.name = name
self.get_session.add(view_menu)
self.get_session.commit()
return view_menu
except Exception as e:
log... |
'Deletes a ViewMenu from the backend
:param name:
name of the ViewMenu'
| def del_view_menu(self, name):
| obj = self.find_view_menu(name)
if obj:
try:
self.get_session.delete(obj)
self.get_session.commit()
except Exception as e:
log.error(c.LOGMSG_ERR_SEC_DEL_PERMISSION.format(str(e)))
self.get_session.rollback()
|
'Finds and returns a PermissionView by names'
| def find_permission_view_menu(self, permission_name, view_menu_name):
| permission = self.find_permission(permission_name)
view_menu = self.find_view_menu(view_menu_name)
return self.get_session.query(self.permissionview_model).filter_by(permission=permission, view_menu=view_menu).first()
|
'Finds all permissions from ViewMenu, returns list of PermissionView
:param view_menu: ViewMenu object
:return: list of PermissionView objects'
| def find_permissions_view_menu(self, view_menu):
| return self.get_session.query(self.permissionview_model).filter_by(view_menu_id=view_menu.id).all()
|
'Adds a permission on a view or menu to the backend
:param permission_name:
name of the permission to add: \'can_add\',\'can_edit\' etc...
:param view_menu_name:
name of the view menu to add'
| def add_permission_view_menu(self, permission_name, view_menu_name):
| vm = self.add_view_menu(view_menu_name)
perm = self.add_permission(permission_name)
pv = self.permissionview_model()
(pv.view_menu_id, pv.permission_id) = (vm.id, perm.id)
try:
self.get_session.add(pv)
self.get_session.commit()
log.info(c.LOGMSG_INF_SEC_ADD_PERMVIEW.format(st... |
'Add permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def add_permission_role(self, role, perm_view):
| if (perm_view not in role.permissions):
try:
role.permissions.append(perm_view)
self.get_session.merge(role)
self.get_session.commit()
log.info(c.LOGMSG_INF_SEC_ADD_PERMROLE.format(str(perm_view), role.name))
except Exception as e:
log.erro... |
'Remove permission-ViewMenu object to Role
:param role:
The role object
:param perm_view:
The PermissionViewMenu object'
| def del_permission_role(self, role, perm_view):
| if (perm_view in role.permissions):
try:
role.permissions.remove(perm_view)
self.get_session.merge(role)
self.get_session.commit()
log.info(c.LOGMSG_INF_SEC_DEL_PERMROLE.format(str(perm_view), role.name))
except Exception as e:
log.error(c.... |
'Method for sending the registration Email to the user'
| def send_email(self, register_user):
| try:
from flask_mail import Mail, Message
except:
log.error('Install Flask-Mail to use User registration')
return False
mail = Mail(self.appbuilder.get_app)
msg = Message()
msg.subject = self.email_subject
url = url_for('.activation', _external=True, activa... |
'Add a registration request for the user.
:rtype : RegisterUser'
| def add_registration(self, username, first_name, last_name, email, password=''):
| register_user = self.appbuilder.sm.add_register_user(username, first_name, last_name, email, password)
if register_user:
if self.send_email(register_user):
flash(as_unicode(self.message), 'info')
return register_user
else:
flash(as_unicode(self.error_message),... |
'Endpoint to expose an activation url, this url
is sent to the user by email, when accessed the user is inserted
and activated'
| @expose('/activation/<string:activation_hash>')
def activation(self, activation_hash):
| reg = self.appbuilder.sm.find_register_user(activation_hash)
if (not reg):
log.error(c.LOGMSG_ERR_SEC_NO_REGISTER_HASH.format(activation_hash))
flash(as_unicode(self.false_error_message), 'danger')
return redirect(self.appbuilder.get_url_for_index)
if (not self.appbuilder.sm.add_user... |
'Hackish method to make use of oid.login_handler decorator.'
| def oid_login_handler(self, f, oid):
| if (request.args.get('openid_complete') != u'yes'):
return f(False)
consumer = Consumer(SessionWrapper(self), oid.store_factory())
openid_response = consumer.complete(request.args.to_dict(), oid.get_current_url())
if (openid_response.status == SUCCESS):
return self.after_login(OpenIDResp... |
'Method that adds the return OpenID response object on the session
this session key will be deleted'
| def after_login(self, resp):
| session['oid_resp'] = resp
|
'Initialization of base permissions
based on exposed methods and actions
Initialization of extra args'
| def __init__(self):
| if (self.base_permissions is None):
self.base_permissions = set()
for attr_name in dir(self):
if hasattr(getattr(self, attr_name), '_permission_name'):
permission_name = getattr(getattr(self, attr_name), '_permission_name')
self.base_permissions.add(('can_... |
'Create Flask blueprint. You will generally not use it
:param appbuilder:
the AppBuilder object
:param endpoint:
endpoint override for this blueprint, will assume class name if not provided
:param static_folder:
the relative override for static folder, if omitted application will use the appbuilder static'
| def create_blueprint(self, appbuilder, endpoint=None, static_folder=None):
| self.appbuilder = appbuilder
self.endpoint = (endpoint or self.__class__.__name__)
if (self.route_base is None):
self.route_base = ('/' + self.__class__.__name__.lower())
self.static_folder = static_folder
if (not static_folder):
self.blueprint = Blueprint(self.endpoint, __name__, ur... |
'Use this method on your own endpoints, will pass the extra_args
to the templates.
:param template: The template relative path
:param kwargs: arguments to be passed to the template'
| def render_template(self, template, **kwargs):
| kwargs['base_template'] = self.appbuilder.base_template
kwargs['appbuilder'] = self.appbuilder
return render_template(template, **dict((list(kwargs.items()) + list(self.extra_args.items()))))
|
'Prettify pythonic variable name.
For example, \'HelloWorld\' will be converted to \'Hello World\'
:param name:
Name to prettify.'
| def _prettify_name(self, name):
| return re.sub('(?<=.)([A-Z])', ' \\1', name)
|
'Prettify pythonic variable name.
For example, \'hello_world\' will be converted to \'Hello World\'
:param name:
Name to prettify.'
| def _prettify_column(self, name):
| return re.sub('[._]', ' ', name).title()
|
'Call it on your own endpoint\'s to update the back history navigation.
If you bypass it, the next submit or back will go over it.'
| def update_redirect(self):
| page_history = Stack(session.get('page_history', []))
page_history.push(request.url)
session['page_history'] = page_history.to_json()
|
'Returns the previous url.'
| def get_redirect(self):
| index_url = self.appbuilder.get_url_for_index
page_history = Stack(session.get('page_history', []))
if (page_history.pop() is None):
return index_url
session['page_history'] = page_history.to_json()
url = (page_history.pop() or index_url)
return url
|
'Returns the url for this class default endpoint'
| @classmethod
def get_default_url(cls, **kwargs):
| return url_for(((cls.__name__ + '.') + cls.default_view), **kwargs)
|
'Will return a list with views that need to be initialized.
Normally related_views from ModelView'
| def get_uninit_inner_views(self):
| return []
|
'Sets initialized inner views'
| def get_init_inner_views(self, views):
| pass
|
'Override this method to implement your form processing'
| def form_get(self, form):
| pass
|
'Override this method to implement your form processing
:param form: WTForm form
Return None or a flask response to render
a custom template or redirect the user'
| def form_post(self, form):
| pass
|
'Constructor'
| def __init__(self, **kwargs):
| datamodel = kwargs.get('datamodel', None)
if datamodel:
self.datamodel = datamodel
self._init_properties()
self._init_forms()
self._init_titles()
super(BaseModelView, self).__init__(**kwargs)
|
'Auto generates pretty label_columns from list of columns'
| def _gen_labels_columns(self, list_columns):
| for col in list_columns:
if (not self.label_columns.get(col)):
self.label_columns[col] = self._prettify_column(col)
|
'Prepares dict with labels to be JSON serializable'
| def _label_columns_json(self):
| ret = {}
for (key, value) in list(self.label_columns.items()):
ret[key] = as_unicode(value.encode('UTF-8'))
return ret
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.