def crea_usuario():
from gluon.validators import CRYPT
from gluon.tools import Auth
db = current.db
auth = Auth(db)
db.Sede.insert(name="Sede de pruebas")
id_almacen = db.Almacen.insert(name="AlmacenTest 1")
db.Almacen.insert(name="AlmacenTest 2")
db.Estanteria.insert(name="Estanteria Test", almacen=id_almacen)
my_crypt = CRYPT(key=auth.settings.hmac_key)
crypted_passwd = my_crypt('password_malo')[0]
db.commit()
db.auth_user.insert(email='*****@*****.**',
first_name='Administrator',
password=crypted_passwd)
auth.add_group('admins', 'Administradores de la aplicación')
auth.add_membership(1, 1)
auth.add_permission(1, 'admins', db.auth_user)
db.Beneficiario.insert(name="Beneficiario 1",
tipobeneficiario="ASOCIACIONES")
db.Colaborador.insert(name="Donante 1", Donante=True)
db.commit()
def create_users():
from gluon.validators import CRYPT
from gluon.tools import Auth
db = current.db
auth = Auth(db)
my_crypt = CRYPT(key=auth.settings.hmac_key)
crypted_passwd = my_crypt('password')[0]
db.commit()
db.auth_user.insert(email='*****@*****.**',
first_name='Administrator',
password=crypted_passwd)
auth.add_group('admins', 'Application Administrators')
auth.add_membership(1, 1)
auth.add_permission(1, 'admins', db.auth_user)
db.commit()
'''
Created on 2012-11-30
@author: fengclient
'''
import sys
sys.path.append('/data/web2py')
from gluon.dal import DAL
from gluon.tools import Auth
if __name__ == '__main__':
db = DAL('sqlite://../app_src/applications/bookit/databases/storage.sqlite')
auth=Auth(db)
g_manager_id=auth.add_group('Manager','can access the manage action/page')
g_user_id=auth.add_group('User','can view and borrow')
g_admin_id=auth.add_group('Admin','everything')
auth.add_permission(g_manager_id,'access to manage')
auth.add_permission(g_manager_id,'access to borrow')
auth.add_permission(g_user_id,'access to borrow')
auth.add_permission(g_admin_id,'access to manage')
auth.add_permission(g_admin_id,'access to borrow')
auth.add_permission(g_admin_id,'access to admin')
pass
# More API examples for controllers:
#
# >>> db.mytable.insert(myfield='value')
# >>> rows = db(db.mytable.myfield == 'value').select(db.mytable.ALL)
# >>> for row in rows: print row.id, row.myfield
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# after defining tables, uncomment below to enable auditing
# -------------------------------------------------------------------------
# auth.enable_record_versioning(db)
'''
Important execute these two lines of code only once.
In fact they generate a new group every time a page is loaded.
'''
group_users_rows = db(db.auth_group.role == 'users').select()
if group_users_rows != None and len(group_users_rows) == 0:
auth.add_group('users', 'generic group for libaray users')
group_librarians_rows = db(db.auth_group.role == 'admins').select()
if group_librarians_rows != None and len(group_librarians_rows) == 0:
auth.add_group('admins', 'group for libaray administrators')
#by default the application creates a new group for each new registered user
#we do not want that, so we force every new user to be part of the "users" group
#http://web2py.com/books/default/chapter/29/09/access-control#Authorization
auth.settings.everybody_group_id = db(db.auth_group.role == 'users').select().first().id
auth.settings.create_user_groups = False
IS_NOT_IN_DB(db, forca_auth.email, error_message='Este e-mail já está cadastrado')]
else:
forca_auth.email.requires = \
[IS_NOT_IN_DB(db, forca_auth.email, error_message='Este e-mail já está cadastrado')]
#auth settings
auth.settings.table_user = forca_auth
auth.settings.registration_requires_verification = True
auth.settings.registration_requires_approval = False
auth.settings.create_user_groups = False
auth.settings.register_next = URL(request.application, 'default', 'user/login')
auth.define_tables(migrate=False)
if not auth.id_group('Aluno'):
auth.add_group('Aluno', 'Aluno')
if not auth.id_group('Professor'):
auth.add_group('Professor', 'Professor')
if not auth.id_group('Admin'):
auth.add_group('Admin', 'Administrador')
#definicao de categoria por email
def is_professor(form):
email = form.vars.email
if len(db(db.professores.email == email).select()) > 0:
auth.add_membership(auth.id_group('Professor'), int(form.vars.id))
prof_create(form.vars)
else:
if email == master_admin:
auth.add_membership(auth.id_group('Admin'), int(form.vars.id))
Field('zip_code', 'string', length=5),
Field('phone', 'string', length=10),
Field('mobile', 'string', length=10)]
auth.define_tables(username=True, migrate=MIGRATE)
auth.settings.controller = 'login'
auth.settings.function = 'index'
auth.settings.login_url = URL('login', 'index')
auth.settings.login_next = URL('default', 'index')
auth.settings.logout_next = URL('login', 'index')
auth.settings.login_after_registration = False
auth.settings.expiration = 18000
try:
if db(db.auth_group).isempty():
god_group_id = auth.add_group('GOD', 'Administrador del sistema')
auth.add_group('Administrador', 'Administrador local')
auth.add_group('Gerente', 'Gerente de sucursal')
auth.add_group('Vendedor de mostrador', 'Vendedor de mostrador'),
auth.add_group('Almacenista', 'Encargado de almacen')
auth.add_group('Cajero', '')
else:
god_group_id = db(db.auth_group.role=='GOD').select().first()
god_group_id = god_group_id.id
if db(db.auth_user).isempty():
password = db.auth_user.password.validate('qazWSX11')[0]
data = dict()
data['first_name'] = 'Yisus'
data['last_name'] = 'Craist'
data['username'] = '******'
Field('n_serie', 'string'), Field('descripcion', 'string'),
Field('disponible', 'boolean'))
db.define_table('categoria', Field('nombre', 'string'),
Field('descripcion', 'string'))
db.define_table('categoria_producto', Field('id_producto', db.producto),
Field('id_categoria', db.categoria))
db.define_table('prestacion', Field('id_user', db.auth_user),
Field('id_inventario', db.inventario),
Field('fecha_prestacion', 'datetime'),
Field('fecha_devolucion', 'time'))
if (db(db.auth_group).isempty()):
auth.add_group('admin', 'admin')
auth.add_group('supervisor', 'supervisor')
auth.add_group('user_basic', 'user_basic')
#Revisar esto
if not db().select(db.auth_user.ALL).first():
id_user = db.auth_user.insert(
username='******',
password=db.auth_user.password.validate('admin')[0],
email='*****@*****.**',
first_name='admin',
last_name='Administrator',
)
auth.del_membership(auth.id_group('user_basic'), id_user)
auth.add_membership(auth.id_group('admin'), id_user)
class Cognito(object):
def __init__(self):
self.db = DAL(
current.config.get("cognito_db.uri"),
pool_size=current.config.get("cognito_db.pool_size"),
migrate_enabled=current.config.get("cognito_db.migrate"),
check_reserved=["all"],
)
self.auth = Auth(db=self.db,
host_names=current.config.get("host.names"))
self.auth.settings.create_user_groups = None
# TODO: extend this during implementation
self.auth.settings.extra_fields["auth_user"] = [
Field("user_attributes", type="json")
]
self.auth.define_tables(username=True, signature=True)
def add_user_to_group(self, username, group_name):
user = self.db(self.db.auth_user.username == username).select()
if not len(user):
raise HTTP(400, "UserNotFoundException")
group = self.db(self.db.auth_group.role == group_name).select()
if len(group):
self.auth.add_membership(group.first().id, user.first().id)
return None
def create_group(self, group_name, description):
if len(self.db(self.db.auth_group.role == group_name).select()):
raise HTTP(400, "GroupExistsException")
result = self.auth.add_group(role=group_name, description=description)
group = self.db(self.db.auth_group.id == result).select().first()
return {
"Group": {
"GroupName": group["role"],
"Description": group["description"],
"LastModifiedDate": group["modified_on"],
"CreationDate": group["created_on"],
}
}
def delete_group(self, group_name):
self.db(self.db.auth_group.role == group_name).delete()
return None
def sign_up(self, username, password, user_attributes):
result = self.auth.register_bare(username=username, password=password)
if not result:
raise HTTP(400, "UsernameExistsException")
result.update_record(user_attributes=user_attributes)
return {
"UserConfirmed":
not self.auth.settings.registration_requires_verification,
"UserSub": result.id,
}
)
# db.define_table(
# 'cohorte',
# Field('id', type='string'),
# Field('estado', type='boolean')
# primarykey=['id'],
# migrate='db.cohorte'
# )
if not db(db.usuario.username == 'admin').select():
id_usuario = db.usuario.insert(username='******', password=CRYPT()('admin')[0], first_name='SisPIO', last_name='Admin', email='*****@*****.**')
estudiante = auth.add_group(role='Estudiante', description='description')
profesor = auth.add_group(role='Profesor', description='description')
representante_liceo = auth.add_group(role='Representante_liceo', description='description')
representante_sede = auth.add_group(role='Representante_sede', description='description')
admin = auth.add_group(role='Administrador', description='description')
auth.add_permission(estudiante, 'Estudiante')
auth.add_permission(profesor, 'Estudiante')
auth.add_permission(profesor, 'Profesor')
auth.add_permission(representante_liceo, 'Estudiante')
auth.add_permission(representante_liceo, 'Representante_liceo')
auth.add_permission(representante_sede, 'Estudiante')
auth.add_permission(representante_sede, 'Representante_sede')
from gluon.tools import Auth
auth = Auth(db, hmac_key=Auth.get_or_create_key())
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
auth.define_tables ()
admin_role = auth.id_group ("Administrator")
if not admin_role:
admin_role = auth.add_group ("Administrator", "System Administrator - can access & make changes to any data")
editor_role = -1
writer_role = -1
def require_logged_in (func):
def wrapper (*args, **kwargs):
if not auth.user:
redirect (URL (r = request, c = 'default', f = 'user', args = ['login']))
return func (*args, **kwargs)
return wrapper
def require_logged_in_deprecated ():
if not auth.user:
redirect (URL (r = request, c = 'default', f = 'user', args = ['login']))
def require_role (role):
def decorator (func):
def wrapper (*args, **kwargs):
if not auth.user:
mail.settings.server = settings.mail.server
mail.settings.sender = settings.mail.sender
mail.settings.login = settings.mail.login
# settings.auth
settings.auth.hmac_key = 'sha512:7a716c8b015b5caca119e195533717fe9a3095d67b3f97114e30256b27392977' # before define_tables()
auth.define_tables(username=True)
if auth.id_group("admin"):
settings.private.admingroup = auth.id_group("admin")
else:
auth.add_group('admin', 'Node admins')
if auth.id_group("targets"):
settings.private.admingroup = auth.id_group("targets")
else:
auth.add_group('targets', 'Targets')
if auth.id_group("candelete"):
settings.private.admingroup = auth.id_group("candelete")
else:
auth.add_group('candelete', 'candelete')
settings.auth.mailer = mail # for user email verification
settings.auth.registration_requires_verification = False
settings.auth.registration_requires_approval = False
auth.messages.verify_email = 'Click on the link http://' + request.env.http_host + \
# configure auth policy
auth.next = None
auth.navbar(referrer_actions=None)
auth.settings.registration_requires_verification = True
auth.messages.email_sent = "A verification email has been sent to you! Follow it's link to proceed."
auth.messages.verify_email_subject = 'Verify your account with ResearchConnect'
#auth.messages.verify_email = 'Thanks for signing up with ResearchConnect! We hope you look forward to connecting with professors and finding the research project you have been searching for. But first, we need you to follow this link' https://toasthater.pythonanywhere.com/ResearchConnect/default/verify_email/%(key)s
auth.settings.login_next = URL('main')
auth.settings.register_next = URL('index')
auth.settings.create_user_groups = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_next = URL('../index')
auth.settings.request_reset_password_next = URL('../index')
auth.settings.reset_password_requires_verification = True
auth.settings.register_verify_password = False
auth.add_group('professor','professor permissions')
auth.add_group('student','student permissions')
#student_group = auth.add_group('student','group that has student permissions')
# More API examples for controllers:
#
# >>> db.mytable.insert(myfield='value')
# >>> rows = db(db.mytable.myfield == 'value').select(db.mytable.ALL)
# >>> for row in rows: print row.id, row.myfield
######################
# Logging
Field('name'),
Field('email'),
Field('imdb_id', 'integer'),
Field('webuser', 'boolean')
)
auth.settings.extra_fields[auth.settings.table_user_name] = [
Field('milo_user', db.users, requires = IS_IN_DB(db,'users.id',db.users._format),
unique=True, notnull=False, writable=False, readable=False, default=lambda: db.users.insert(webuser=True))]
## create all tables needed by auth if not custom tables
auth.define_tables()
## privilege group
rsc_group = auth.add_group(role = 'rsc')
auth.settings.everybody_group_id = rsc_group
dis_group = auth.add_group(role = 'disabled')
destr_group = auth.add_group(role = 'destr')
## manual privilege management
auth.add_membership('rsc',9)
auth.add_membership('admin',9)
## configure email
mail=auth.settings.mailer
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = mail_string
#mail.settings.login = None
IS_NOT_IN_DB(db, custom_auth_table.email)
]
## create all tables needed by auth if not custom tables
auth.define_tables()
## configure email
mail = auth.settings.mailer
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
## configure auth policy
generalAuth = auth.id_group(role="General")
if auth.id_group(role="General") <= 0:
generalAuth = auth.add_group(role="General")
if auth.id_group(role="Admin") <= 0:
adminAuth = auth.add_group(role="Admin")
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
auth.settings.password_min_length = 5
##auth.settings.everybody_group_id = 5
## if you need to use OpenID, Facebook, MySpace, Twitter, Linkedin, etc.
## register with janrain.com, write your domain:api_key in private/janrain.key
from gluon.contrib.login_methods.rpx_account import use_janrain
use_janrain(auth, filename='private/janrain.key')
#########################################################################
## Define your tables below (or better in another model file) for example
forca_auth.email.requires = [
IS_EMAIL(forced="inf\.ufrgs\.br", error_message="O e-mail deve ser @inf.ufrgs.br"),
IS_NOT_IN_DB(db, forca_auth.email, error_message="Este e-mail já está cadastrado"),
]
# auth settings
auth.settings.table_user = forca_auth
auth.settings.registration_requires_verification = True
auth.settings.registration_requires_approval = False
auth.settings.create_user_groups = False
auth.settings.register_next = URL(request.application, "default", "user/login")
auth.define_tables()
if not auth.id_group("Aluno"):
auth.add_group("Aluno", "Aluno do Instituto de Informática")
if not auth.id_group("Professor"):
auth.add_group("Professor", "Professor do Instituto de Informática")
if not auth.id_group("Admin"):
auth.add_group("Admin", "Administrador do sistema")
# definicao de categoria por email
def is_professor(form):
email = form.vars.email
if len(db(db.professores.email == email).select()) > 0:
auth.add_membership(auth.id_group("Professor"), int(form.vars.id))
prof_create(form.vars)
else:
auth.add_membership(auth.id_group("Aluno"), int(form.vars.id))
aluno_create(form.vars)
## Consult manual for more options, validators, etc.
##
## More API examples for controllers:
##
## >>> db.mytable.insert(myfield='value')
## >>> rows=db(db.mytable.myfield=='value').select(db.mytable.ALL)
## >>> for row in rows: print row.id, row.myfield
#########################################################################
from gluon.tools import Crud
crud = Crud(db)
from gluon.tools import Auth
auth = Auth(db, hmac_key=Auth.get_or_create_key())
auth.define_tables()
auth.add_group('role','description')
db.define_table('kids',
Field('username',unique=True),
Field('password',"password"),
Field('rno',"integer",default=None),
format='%(username)s'
)
db.define_table('rooms',
Field('rnum','integer',unique=True),
Field('vidurl'),
Field('active','boolean'),
Field('framenum','integer'),
Field('file','upload'),
Field('flashfile'),
password=CRYPT()('admin')[0],
first_name='Apolo',
last_name='Bomberos',
email='*****@*****.**',
confirmed=True)
id_persona = db.persona.insert(cedula=-1,
primer_nombre='Apolo',
primer_apellido='Bomberos',
email_principal='*****@*****.**',
genero='Masculino')
db.bombero.insert(carnet=-1,
cargo='Administrador',
id_persona=id_persona,
id_usuario=id_usuario)
estudiante = auth.add_group(role='Estudiante', description='description')
bombero = auth.add_group(role='Bombero', description='description')
gerencia = auth.add_group(role='Gerencia', description='description')
inspectoria = auth.add_group(role='Inspectoria', description='description')
comandancia = auth.add_group(role='Comandancia', description='description')
admin = auth.add_group(role='Administrador', description='description')
auth.add_permission(estudiante, 'Estudiante')
auth.add_permission(bombero, 'Estudiante')
auth.add_permission(bombero, 'Bombero')
auth.add_permission(gerencia, 'Estudiante')
auth.add_permission(gerencia, 'Bombero')
auth.add_permission(gerencia, 'Gerencia')
mail = Mail()
## configure email
mail=auth.settings.mailer
mail.settings.server = 'logging' or 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = None
## configure auth policy
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
auth.settings.allow_basic_login = True
auth.settings.actions_disabled.append('register')
auth.add_group('admins', 'Overall site admins, intended to have constant administrative access')
## if you need to use OpenID, Facebook, MySpace, Twitter, Linkedin, etc.
## register with janrain.com, write your domain:api_key in private/janrain.key
from gluon.contrib.login_methods.rpx_account import use_janrain
use_janrain(auth,filename='private/janrain.key')
#########################################################################
## Define your tables below (or better in another model file) for example
##
## >>> db.define_table('mytable',Field('myfield','string'))
##
## Fields can be 'string','text','password','integer','double','boolean'
## 'date','time','datetime','blob','upload', 'reference TABLENAME'
## There is an implicit 'id integer autoincrement' field
## Consult manual for more options, validators, etc.
## Consult manual for more options, validators, etc.
##
## More API examples for controllers:
##
## >>> db.mytable.insert(myfield='value')
## >>> rows=db(db.mytable.myfield=='value').select(db.mytable.ALL)
## >>> for row in rows: print row.id, row.myfield
#########################################################################
from gluon.tools import Crud
crud = Crud(db)
from gluon.tools import Auth
auth = Auth(db, hmac_key=Auth.get_or_create_key())
auth.define_tables()
auth.add_group('role', 'description')
db.define_table('kids',
Field('username', unique=True),
Field('password', "password"),
Field('rno', "integer", default=None),
format='%(username)s')
db.define_table('rooms',
Field('rnum', 'integer', unique=True),
Field('vidurl'),
Field('active', 'boolean'),
Field('framenum', 'integer'),
Field('file', 'upload'),
Field('flashfile'),
format='%(rnum)s')
# initialize admin user and roles group:
useradmin = db(db.auth_user.id == 1).select()
if len(useradmin) == 0:
db.Sede.insert(name="Sede de pruebas")
db.Almacen.insert(name="AlmacenTest")
my_crypt = CRYPT(key=auth.settings.hmac_key)
crypted_passwd = my_crypt('password_malo')[0]
db.commit()
# k = db.auth_user.insert(email='*****@*****.**', first_name='Administrator',
# password=crypted_passwd, almacen=1)
k = db.auth_user.insert(email='*****@*****.**', first_name='Administrator',
password=crypted_passwd)
if str(k) != '1':
db.executesql('update auth_user set id=1 where id=' + str(k))
k = auth.add_group('admins', 'Administradores de la aplicación')
if str(k) != '1':
db.executesql('update auth_group set id=1 where id=' + str(k))
auth.add_membership(1, 1)
auth.add_permission(1, 'admins', db.auth_user)
db.commit()
# Temporal, para importar datos de bb.dd. anterior ###
import importacion
locs = db().select(db.poblacion.ALL, limitby=(0, 1))
if not locs:
# importacion.rellena_familias()
# importacion.rellena_subfamilias()
# importacion.rellena_alimentos()
importacion.rellena_paises()
Field('medicamento_alergia', default="", type="string"),
Field('otra_enfermedad', default="", type="string"),
Field('tlf_rep', default="", type="string"),
Field('direccion', default="", type="string"),
Field('observacion', default="", type="string"),
Field('representante', 'reference usuario'))
if not db(db.auth_membership.group_id == 4).select():
# Primer Usuario del Sistema
id_usuario = db.usuario.insert(password=CRYPT()('admin')[0],
first_name='admin',
last_name='admin',
email='*****@*****.**')
# Roles
cuidador = auth.add_group(role='Cuidador')
maestro = auth.add_group(role='Maestro')
representante = auth.add_group(role='Representante')
admin = auth.add_group(role='Administrador')
# Permisos para cada rol
auth.add_permission(representante, 'Representante')
auth.add_permission(maestro, 'Maestro')
auth.add_permission(cuidador, 'Cuidador')
auth.add_permission(admin, 'Representante')
auth.add_permission(admin, 'Maestro')
auth.add_permission(admin, 'Cuidador')
auth.add_permission(admin, 'Administrador')
def construct_permissions():
"""Automatically construct permissions hierarchy"""
# logger = logzero.setup_logger(logfile="web2py.log",
# formatter=logging.Formatter(
# '%(asctime)s - %(levelname)-7s - %(funcName)s - %(message)s'),
# disableStderrLogger=True)
# logger.info("Constructing permissions system...")
print("Constructing permissions system...")
#
# logger.info("Linking to db...")
db = current.db
auth = Auth(db)
try:
# logger.info("Creating user groups...")
groupid_vbadmin = auth.add_group("VectorbiteAdmin", "Administrator group, has all permissions.")
groupid_vdview = auth.add_group("VD Viewer", "Can view VecDyn.")
groupid_vtview = auth.add_group("VT Viewer", "Can view VecTraits.")
groupid_vdupload = auth.add_group("VD Uploader", "Can view and upload to VecDyn.")
groupid_vtupload = auth.add_group("VT Uploader", "Can view and upload to VecTraits.")
groupid_vdcurate = auth.add_group("VD Curator", "Can view, upload to, and curate VecDyn.")
groupid_vtcurate = auth.add_group("VT Curator", "Can view, upload to, and curate VecTraits.")
groupid_viewall = auth.add_group("View All", "Can view both databases.")
# logger.info("Creating permissions...")
# logger.debug("Adding permissions for Admin...")
auth.add_permission(groupid_vbadmin, "view", "vecdyn")
auth.add_permission(groupid_vbadmin, "upload", "vecdyn")
auth.add_permission(groupid_vbadmin, "curate", "vecdyn")
auth.add_permission(groupid_vbadmin, "view", "vectraits")
auth.add_permission(groupid_vbadmin, "upload", "vectraits")
auth.add_permission(groupid_vbadmin, "curate", "vectraits")
# logger.debug("Adding permissions for View accounts...")
auth.add_permission(groupid_vdview, "view", "vecdyn")
auth.add_permission(groupid_vtview, "view", "vectraits")
# logger.debug("Adding permissions for Upload accounts...")
auth.add_permission(groupid_vdupload, "view", "vecdyn")
auth.add_permission(groupid_vdupload, "upload", "vecdyn")
auth.add_permission(groupid_vtupload, "view", "vectraits")
auth.add_permission(groupid_vtupload, "upload", "vectraits")
# logger.debug("Adding permissions for Curator accounts...")
auth.add_permission(groupid_vdcurate, "view", "vecdyn")
auth.add_permission(groupid_vdcurate, "upload", "vecdyn")
auth.add_permission(groupid_vdcurate, "curate", "vecdyn")
auth.add_permission(groupid_vtcurate, "view", "vectraits")
auth.add_permission(groupid_vtcurate, "upload", "vectraits")
auth.add_permission(groupid_vtcurate, "curate", "vectraits")
# logger.debug("Adding permissions for Viewall account...")
auth.add_permission(groupid_viewall, "view", "vecdyn")
auth.add_permission(groupid_viewall, "view", "vectraits")
# logger.info("Permission complete, comitting db...")
db.commit()
except Exception:
# logger.exception("Encountered exception when constructing permissions system. Rolling back.")
print("Encountered exception when constructing permissions system. Rolling back.")
db.rollback()
# logger.info("Permissions system created")
return True
IS_NOT_IN_DB(db, forca_auth.email, error_message='Este e-mail já está cadastrado')]
else:
forca_auth.email.requires = \
[IS_NOT_IN_DB(db, forca_auth.email, error_message='Este e-mail já está cadastrado')]
#auth settings
auth.settings.table_user = forca_auth
auth.settings.registration_requires_verification = True
auth.settings.registration_requires_approval = False
auth.settings.create_user_groups = False
auth.settings.register_next = URL(request.application, 'default', 'user/login')
auth.define_tables()
if not auth.id_group('Aluno'):
auth.add_group('Aluno', 'Aluno')
if not auth.id_group('Professor'):
auth.add_group('Professor', 'Professor')
if not auth.id_group('Admin'):
auth.add_group('Admin', 'Administrador')
#definicao de categoria por email
def is_professor(form):
email = form.vars.email
if len(db(db.professores.email==email).select()) > 0:
auth.add_membership(auth.id_group('Professor'), int(form.vars.id))
prof_create(form.vars)
else:
if email == master_admin:
auth.add_membership(auth.id_group('Admin'), int(form.vars.id))
auth.add_membership(auth.id_group('Aluno'), int(form.vars.id))
# -*- coding: utf-8 -*-
authdb = DAL('sqlite://auth.db')
from gluon.tools import Auth
auth = Auth(authdb, signature=False, csrf_prevention = False)
auth.define_tables(username=True, signature=False)
auth.settings.registration_requires_approval = True
auth.settings.create_user_groups = None
auth.settings.actions_disabled.append('register')
auth.settings.actions_disabled.append('request_reset_password')
# Only will be done on first load
if not authdb(authdb.auth_user.id>0).count():
# create groups
vels_admin_group = auth.add_group('vels_admin', 'can change settings, can view statistics')
vels_tutor_group = auth.add_group('vels_tutor', 'can view settings, can view statistics')
# create initial admin
fname = "vels_admin"
lname = "vels_admin"
email = "*****@*****.**"
username = "******"
passwd = "vels_admin"
hashed_passwd = authdb.auth_user.password.requires[0](passwd)[0]
initial_admin = authdb.auth_user.insert(first_name=fname,last_name=lname,email=email,
password=hashed_passwd, username=username)
# make initial admin member of group vels_admins
auth.add_membership(vels_admin_group, initial_admin)
## - email capabilities
## - authentication (registration, login, logout, ... )
## - authorization (role based authorization)
## - services (xml, csv, json, xmlrpc, jsonrpc, amf, rss)
## - old style crud actions
## (more options discussed in gluon/tools.py)
#########################################################################
from gluon.tools import Auth, Crud, Service, PluginManager, prettydate
auth = Auth(db)
crud, service, plugins = Crud(db), Service(), PluginManager()
## create all tables needed by auth if not custom tables
auth.define_tables(username=False, signature=False)
if (db(db.auth_group.role == 'viewer').isempty()):
auth.add_group ('viewer')
if (db(db.auth_group.role == 'poster').isempty()):
auth.add_group ('poster')
## configure email
mail = auth.settings.mailer
mail.settings.server = 'logging' or 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
## configure auth policy
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
## if you need to use OpenID, Facebook, MySpace, Twitter, Linkedin, etc.
IS_EMAIL(error_message=auth.messages.invalid_email),
IS_NOT_IN_DB(db, custom_auth_table.email)]
## create all tables needed by auth if not custom tables
auth.define_tables()
## configure email
mail=auth.settings.mailer
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
## configure auth policy
generalAuth = auth.id_group(role="General");
if auth.id_group(role="General")<=0:
generalAuth = auth.add_group(role="General")
if auth.id_group(role="Admin")<=0:
adminAuth = auth.add_group(role="Admin")
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
auth.settings.password_min_length = 5
##auth.settings.everybody_group_id = 5
## if you need to use OpenID, Facebook, MySpace, Twitter, Linkedin, etc.
## register with janrain.com, write your domain:api_key in private/janrain.key
from gluon.contrib.login_methods.rpx_account import use_janrain
use_janrain(auth,filename='private/janrain.key')
#########################################################################
## Define your tables below (or better in another model file) for example
