def __init__(self, DALDatabase):
self.DALDatabase = DALDatabase
self.DALDatabase.define_table(
'internal_messages',
Field('senders',
'reference auth_user',
notnull=True,
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('subject', 'string', requires=IS_NOT_EMPTY()),
Field('text_message', 'string', requires=IS_NOT_EMPTY()),
Field('message_sent', 'boolean', default=False),
Field('send_on', 'datetime', requires=IS_EMPTY_OR(IS_DATETIME())),
Field('written_on',
'datetime',
default=datetime.now(),
requires=IS_EMPTY_OR(IS_DATETIME())))
self.DALDatabase.define_table(
'internal_messages_recipients',
Field('internal_messages',
'reference internal_messages',
notnull=True,
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.internal_messages)),
Field('recipients',
'reference auth_user',
notnull=True,
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('message_read', 'boolean', default=False),
)
def change_password(self):
self._check_logged("change_password")
user = self.auth.db.auth_user(self.auth.user_id)
form = Form(
[
Field("old_password", type="password", requires=IS_NOT_EMPTY()),
Field(
"new_password",
type="password",
requires=self.auth.db.auth_user.password.requires,
),
Field("new_password_again", type="password", requires=IS_NOT_EMPTY()),
]
)
if form.submitted:
old_password = form.post_vars.get("new_password")
new_password = form.post_vars.get("new_password")
if form.post_vars["new_password_again"] != new_password:
form.errors["new_password_again"] = "Passwords do not match"
form.accepted = False
else:
res = self.auth.change_password(
user, new_password, old_password, check=True
)
form.errors = re.get("errors", {})
form.accepted = not res.get("errors")
self._postprocessng("profile", form, user)
return form
def define_tables(self):
"""Defines the auth_user table"""
db = self.db
Field = db.Field
if not "auth_user" in db.tables:
ne = IS_NOT_EMPTY()
auth_fields = [
Field(
"email",
requires=(IS_EMAIL(), IS_NOT_IN_DB(db, "auth_user.email")),
unique=True,
),
Field(
"password",
"password",
requires=CRYPT(),
readable=False,
writable=False,
),
Field("first_name", requires=ne),
Field("last_name", requires=ne),
Field("sso_id", readable=False, writable=False),
Field("action_token", readable=False, writable=False),
]
if self.use_username:
auth_fields.insert(
0,
Field(
"username",
requires=[ne, IS_NOT_IN_DB(db, "auth_user.username")],
unique=True,
),
)
db.define_table("auth_user", *auth_fields, *self.extra_auth_user_fields)
def reset_password(self):
form = Form([Field("password", type="password")])
user = None
token = request.query.get("token")
if token:
query = self.auth._query_from_token(token)
user = self.auth.db(query).select().first()
if not user:
raise HTTP(404)
user = self.auth.db.auth_user(self.auth.user_id)
form = Form(
[
Field(
"new_password",
type="password",
requires=self.auth.db.auth_user.password.requires,
),
Field("new_password_again", type="password", requires=IS_NOT_EMPTY()),
]
)
if form.submitted:
new_password = form.post_vars.get("new_password")
if form.post_vars["new_password_again"] != new_password:
form.errors["new_password_again"] = "Passwords do not match"
form.accepted = False
else:
res = self.auth.change_password(
user, new_password, check=True, check_old_password=False
)
form.errors = re.get("errors", {})
form.accepted = not res.get("errors")
self._postprocessng("profile", form, user)
return form
def define_tables(self):
"""Defines the auth_user table"""
db = self.db
Field = db.Field
if not "auth_user" in db.tables:
ne = IS_NOT_EMPTY()
if self.password_complexity:
requires = [IS_STRONG(**self.password_complexity), CRYPT()]
else:
requires = [CRYPT()]
auth_fields = [
Field(
"email",
requires=(IS_EMAIL(), IS_NOT_IN_DB(db, "auth_user.email")),
unique=True,
),
Field(
"password",
"password",
requires=requires,
readable=False,
writable=False,
),
Field("first_name", requires=ne),
Field("last_name", requires=ne),
Field("profile_pic", default="https://merriam-webster.com/assets/mw/images/article/art-wap-landing-mp-lg/[email protected]"),
Field("sso_id", readable=False, writable=False),
Field("action_token", readable=False, writable=False),
Field(
"last_password_change",
"datetime",
default=None,
readable=False,
writable=False,
),
]
if self.use_username:
auth_fields.insert(
0,
Field(
"username",
requires=[ne, IS_NOT_IN_DB(db, "auth_user.username")],
unique=True,
),
)
if self.use_phone_number:
auth_fields.insert(
2,
Field(
"phone_number",
requires=[
ne,
IS_MATCH(r"^[+]?(\(\d+\)|\d+)(\(\d+\)|\d+|[ -])+$"),
],
),
)
if self.block_previous_password_num is not None:
auth_fields.append(
Field("past_passwords_hash", "list:string", writable=False, readable=False))
db.define_table("auth_user", *auth_fields, *self.extra_auth_user_fields)
def reset_password(self):
user = None
token = request.query.get("token")
if token:
query = self.auth._query_from_token(token)
user = self.auth.db(query).select().first()
if not user:
raise HTTP(404)
user = self.auth.db.auth_user(self.auth.user_id)
form = Form(
[
Field(
"new_password",
type="password",
requires=self.auth.db.auth_user.password.requires,
),
Field("new_password_again",
type="password",
requires=IS_NOT_EMPTY()),
],
formstyle=self.formstyle,
)
self._process_change_password_form(form, user)
if form.accepted:
self._postprocessing("reset_password", form, user)
return form
def change_password(self):
user = self.auth.db.auth_user(self.auth.user_id)
form = Form(
[
Field(
"old_password",
type="password",
requires=IS_NOT_EMPTY(),
label=self.auth.param.messages["labels"].get("old_password"),
),
Field(
"new_password",
type="password",
requires=self.auth.db.auth_user.password.requires,
label=self.auth.param.messages["labels"].get("new_password"),
),
Field(
"new_password_again",
type="password",
requires=IS_EQUAL_TO(request.forms.get("new_password")),
label=self.auth.param.messages["labels"].get("password_again"),
),
],
formstyle=self.formstyle,
submit_value=self.auth.param.messages["buttons"]["submit"],
)
self._process_change_password_form(form, user, True)
if form.accepted:
self._set_flash("password-changed")
self._postprocessing("change_password", form, user)
return form
def request_reset_password(self):
form = Form(
[
Field(
"email",
label=self.auth.param.messages["labels"].get("username_or_email"),
requires=IS_NOT_EMPTY(),
)
],
submit_value=self.auth.param.messages["buttons"]["request"],
formstyle=self.formstyle,
)
if form.accepted:
email = form.vars.get("email", "")
self.auth.request_reset_password(email, send=True, next="")
self._set_flash("password-reset-link-sent")
self._postprocessing("request_reset_password", form, None)
form.param.sidecar.append(
A(
self.auth.param.messages["buttons"]["sign-in"],
_href="../auth/login",
_class=self.auth.param.button_classes["sign-in"],
_role="button",
)
)
if self.auth.allows("register"):
form.param.sidecar.append(
A(
self.auth.param.messages["buttons"]["sign-up"],
_href="../auth/register",
_class=self.auth.param.button_classes["sign-up"],
_role="button",
)
)
return form
def define_tables(self):
"""Defines the auth_user table"""
db = self.db
Field = db.Field
if not "auth_user" in db.tables:
ne = IS_NOT_EMPTY()
if self.password_complexity:
requires = [IS_STRONG(**self.password_complexity), CRYPT()]
else:
requires= [CRYPT()]
auth_fields = [
Field(
"email",
requires=(IS_EMAIL(), IS_NOT_IN_DB(db, "auth_user.email")),
unique=True,
),
Field(
"password",
"password",
requires=requires,
readable=False,
writable=False,
),
Field("first_name", requires=ne),
Field("last_name", requires=ne),
Field("sso_id", readable=False, writable=False),
Field("action_token", readable=False, writable=False),
Field(
"last_password_change",
"datetime",
default=None,
readable=False,
writable=False,
),
]
if self.use_username:
auth_fields.insert(
0,
Field(
"username",
requires=[ne, IS_NOT_IN_DB(db, "auth_user.username")],
unique=True,
),
)
if self.use_phone_number:
auth_fields.insert(
2,
Field(
"phone_number",
requires=[
ne,
IS_MATCH(r"^[+]?(\(\d+\)|\d+)(\(\d+\)|\d+|[ -])+$"),
],
),
)
if self.block_previous_password_num is not None:
auth_fields.append(
Field("past_passwords_hash", "list:string", writable=False, readable=False))
db.define_table("auth_user", *auth_fields, *self.extra_auth_user_fields)
def multiple_form_example():
name = Field('name', requires=IS_NOT_EMPTY())
forms = [
Form([Field('name', requires=IS_NOT_EMPTY())],
form_name='1', formstyle=FormStyleBulma),
Form([Field('name', requires=IS_NOT_EMPTY())],
form_name='2', keep_values=True, formstyle=FormStyleBulma),
Form([Field('name', requires=IS_NOT_EMPTY()),
Field('age','integer')],
form_name='3', formstyle=FormStyleBulma),
Form([Field('name', requires=IS_NOT_EMPTY()),
Field('insane','boolean')],
form_name='4', formstyle=FormStyleBulma),
Form([Field('name', requires=IS_NOT_EMPTY()),
Field('color',requires=IS_IN_SET(['red','blue','gree']))],
form_name='5', formstyle=FormStyleBulma),
Form([Field('name', requires=IS_NOT_EMPTY()),
Field('favorite_thing', requires=IS_IN_DB(db, 'thing.id', 'thing.name'))],
form_name='6', formstyle=FormStyleBulma)]
messages = []
for form in forms:
if form.accepted:
messages.append('form %s accepted with: %s ' % (form.form_name, form.vars))
elif form.errors:
messages.append('form %s has errors: %s ' % (form.form_name, form.errors))
return dict(forms=forms, messages=messages)
def change_password(self):
user = self.auth.db.auth_user(self.auth.user_id)
form = Form(
[
Field("old_password", type="password",
requires=IS_NOT_EMPTY()),
Field(
"new_password",
type="password",
requires=self.auth.db.auth_user.password.requires,
),
Field("new_password_again",
type="password",
requires=IS_NOT_EMPTY()),
],
formstyle=self.formstyle,
)
self._process_change_password_form(form, user)
if form.accepted:
self._postprocessing("change_password", form, user)
return form
def example_multiple_forms():
name = Field("name", requires=IS_NOT_EMPTY())
forms = [
Form(
[Field("name", requires=IS_NOT_EMPTY())],
form_name="1",
formstyle=FormStyleDefault,
),
Form(
[Field("name", requires=IS_NOT_EMPTY())],
form_name="2",
keep_values=True,
formstyle=FormStyleDefault,
),
Form(
[Field("name", requires=IS_NOT_EMPTY()),
Field("age", "integer")],
form_name="3",
formstyle=FormStyleDefault,
),
Form(
[
Field("name", requires=IS_NOT_EMPTY()),
Field("insane", "boolean")
],
form_name="4",
formstyle=FormStyleDefault,
),
Form(
[
Field("name", requires=IS_NOT_EMPTY()),
Field("color", requires=IS_IN_SET(["red", "blue", "green"])),
],
form_name="5",
formstyle=FormStyleDefault,
),
Form(
[
Field("name", requires=IS_NOT_EMPTY()),
Field("favorite_hero",
requires=IS_IN_DB(db, "person.id", "person.name")),
],
form_name="6",
formstyle=FormStyleDefault,
),
]
messages = []
for form in forms:
if form.accepted:
messages.append("form %s accepted with: %s " %
(form.form_name, form.vars))
elif form.errors:
messages.append("form %s has errors: %s " %
(form.form_name, form.errors))
return dict(forms=forms, messages=messages)
def define_tables(self):
db = self.db
Field = db.Field
if not 'auth_user' in db.tables:
ne = IS_NOT_EMPTY()
db.define_table(
'auth_user',
Field('email', requires=(IS_EMAIL(), IS_NOT_IN_DB(db, 'auth_user.email')), unique=True),
Field('password','password', requires=CRYPT(), readable=False),
Field('first_name', requires=ne),
Field('last_name', requires=ne),
Field('sso_id', editable=False, readable=False),
Field('action_token', editable=False, readable=False),
*self.extra_auth_user_fields)
def __init__(self, projectConfig, DALDatabase):
self.DALDatabase = DALDatabase
self.DALDatabase.define_table(
'auth_cas', Field('email', 'string', notnull=True, unique=True),
Field('password_hash',
'string',
notnull=True,
requires=IS_NOT_EMPTY()))
self.DALDatabase.auth_cas.email.requires = [
IS_EMAIL(),
IS_NOT_IN_DB(self.DALDatabase,
self.DALDatabase.auth_cas.email,
error_message="Email already in database.")
]
self.DALDatabase.define_table(
'cas_activity',
Field('auth_cas',
'reference auth_cas',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_cas)),
Field('request', 'text'), Field('activity', 'string'),
Field('date_activity', 'datetime', default=datetime.now()))
self.DALDatabase.define_table(
'apps_authorization', Field('app_name', 'string'),
Field('auth_cas',
'reference auth_cas',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_cas)),
Field('origin', 'string'),
Field('authorization', 'text', requires=IS_NOT_EMPTY()))
self.DALDatabase.apps_authorization.app_name.requires = [
IS_NOT_EMPTY(),
IS_NOT_IN_DB(self.DALDatabase,
self.DALDatabase.apps_authorization.app_name,
error_message="Email already in database.")
]
def define_tables(self):
"""Defines the auth_user table"""
db = self.db
Field = db.Field
if not 'auth_user' in db.tables:
ne = IS_NOT_EMPTY()
auth_fields = [
Field('email', requires=(IS_EMAIL(), IS_NOT_IN_DB(db, 'auth_user.email')), unique=True),
Field('password','password', requires=CRYPT(), readable=False, writable=False),
Field('first_name', requires=ne),
Field('last_name', requires=ne),
Field('sso_id', readable=False, writable=False),
Field('action_token', readable=False, writable=False),
]
if self.use_username:
auth_fields.insert(
0, Field('username', requires=[ne, IS_NOT_IN_DB(db, 'auth_user.username')], unique=True))
db.define_table(
'auth_user',
*auth_fields,
*self.extra_auth_user_fields)
import os
from py4web import *
from py4web.utils.form import Form, FormStyleBulma
from pydal.validators import IS_NOT_EMPTY, IS_INT_IN_RANGE, IS_IN_SET, IS_IN_DB
from yatl.helpers import INPUT, H1
db = DAL('sqlite://test',
folder=os.path.join(os.path.dirname(__file__), 'databases'))
db.define_table('thing',
Field('name', requires=IS_NOT_EMPTY()),
Field('size', 'integer', requires=IS_INT_IN_RANGE(0, 10)),
format='%(name)s')
db.define_table('order', Field('code', requires=IS_NOT_EMPTY()),
Field('thing', 'reference thing'))
if db(db.thing).count() == 0:
db.thing.insert(name='pants', size=1)
db.thing.insert(name='shirt', size=1)
db.order.insert(code='123', thing=1)
db.commit()
session = Session(secret='myscret')
@action('do/nothing')
def do_nothing():
return 'ok'
@action('oops')
def oops():
import os
from py4web import DAL, Field
from pydal.validators import IS_NOT_EMPTY, IS_NOT_IN_DB
# define database and tables
db = DAL('sqlite://storage.db',
folder=os.path.join(os.path.dirname(__file__), 'databases'))
# simple table example
db.define_table('person',
Field('name', requires=IS_NOT_IN_DB(db, 'person.name')),
Field('job', requires=IS_NOT_EMPTY()))
# simple reference example
db.define_table('superhero', Field('name'),
Field('real_identity', 'reference person'))
db.define_table('superpower', Field('description'))
# many to many example
db.define_table('tag', Field('superhero', 'reference superhero'),
Field('superpower', 'reference superpower'),
Field('strength', 'integer'))
if not db(db.person).count():
db.person.insert(name='Clark Kent', job='Journalist')
db.person.insert(name='Peter Park', job='Photographer')
db.person.insert(name='Bruce Wayne', job='CEO')
db.superhero.insert(name='Superman', real_identity=1)
db.superhero.insert(name='Spiderman', real_identity=2)
db.superhero.insert(name='Batman', real_identity=3)
db.superpower.insert(description='Flight')
def p4wupload_file():
t_id = dict(request.query).get("id_", "0")
# if t_id != '0':
# flash.set(f"deleted id={t_id}", sanitize=True)
if not os.path.isdir(UPLOAD_FOLDER):
return f"bad upload path: {UPLOAD_FOLDER}"
messages = []
tbl = "uploaded_files"
upload_field = "image"
upload_form = Form(
[
Field(upload_field, "upload", label="", requires=IS_NOT_EMPTY(),),
Field("remark", default="mycomment"),
],
formstyle=FormStyleDefault,
)
if upload_form.accepted and hasattr(request, "files"):
bottle_class = request.files.get(upload_field, None)
if bottle_class:
orig_fnm = bottle_class.raw_filename
orig_fnm_content = bottle_class.file.read()
uniq_file_name = get_unique_name(orig_fnm,)
data2file(orig_fnm_content, os.path.join(UPLOAD_FOLDER, uniq_file_name))
row = dict(
orig_file_name=orig_fnm,
uniq_file_name=uniq_file_name,
remark=upload_form.vars["remark"],
)
if db[tbl].insert(**db[tbl]._filter_fields(row)):
db.commit()
elif upload_form.errors:
messages.append(f"upload_form has errors: {upload_form.errors}")
hlinks = ["save", "del"]
links = [
lambda tx, r_id: A(
f"save:[{r_id}]",
_title="save file to disk",
_href=URL(f"p4wdownload_file", vars=dict(t_=tx, id_=r_id)),
),
lambda tx, r_id: A(
f"del:[{r_id}]",
_title="run p4wdelete_file",
_href=URL(f"p4wdelete_file", vars=dict(t_=tx, id_=r_id)),
),
]
fld_links = {
# 'id': lambda tx, xx, r_id: A(
# f'save[{r_id}]',
# _title='save file to disk',
# _href=URL(f"p4wdownload_file", vars=dict(t_=tx, x_=xx, id_=r_id)),
# ),
"time": lambda tx, xx, r_id: SPAN(xx.strftime(DATE_FORMAT), _style="color:red"),
}
mygrid = sql2table(
tbl,
db,
links=links,
hlinks=hlinks,
fld_links=fld_links,
rows_on_page=2,
caller="p4wupload_file",
page_d=dict(request.query),
)
return dict(messages=messages, upload_form=upload_form, mygrid=mygrid)
from .common import *
from pydal.validators import IS_NOT_EMPTY
db.define_table("feed_item", Field("body", "text", requires=IS_NOT_EMPTY()),
auth.signature)
db.define_table("item_like", Field("item_id", "reference feed_item"),
auth.signature)
db.define_table(
"friend_request",
Field("from_user", "reference auth_user"),
Field("to_user", "reference auth_user"),
Field("status", options=("accepted", "rejected", "pending")),
)
db.commit()
def get_time():
return datetime.datetime.utcnow()
def get_download_url(picture):
return f"images/{picture}"
def get_user():
return auth.current_user.get("id") if auth.current_user else None
db.define_table(
"post",
Field("title", "string", requires=IS_NOT_EMPTY()),
Field("content", "text", requires=IS_NOT_EMPTY()),
Field("date_posted", "datetime", default=get_time, readable=False, writable=False),
Field(
"author",
"reference auth_user",
default=get_user,
readable=False,
writable=False,
),
)
db.define_table(
"profile",
Field("user", "reference auth_user", readable=False, writable=False),
Field(
import os
from web3py import *
from web3py.utils.form import Form, FormStyleBulma
from pydal.validators import IS_NOT_EMPTY, IS_INT_IN_RANGE, IS_IN_SET, IS_IN_DB
from yatl.helpers import INPUT, H1
db = DAL('sqlite://test', folder=os.path.join(os.path.dirname(__file__), 'databases'))
db.define_table('thing',
Field('name', requires=IS_NOT_EMPTY()),
Field('size','integer', requires=IS_INT_IN_RANGE(0,10)),
format='%(name)s')
db.define_table(
'order',
Field('code', requires=IS_NOT_EMPTY()),
Field('thing', 'reference thing'))
if db(db.thing).count() == 0:
db.thing.insert(name='pants', size=1)
db.thing.insert(name='shirt', size=1)
db.order.insert(code='123', thing=1)
db.commit()
session = Session(secret='myscret')
@action('do/nothing')
def do_nothing():
return 'ok'
@action('oops')
def oops():
1/0
def __init__(self,
projectConfig,
DALDatabase,
i18nTranslator=None,
logger_api=None):
self.DALDatabase = DALDatabase
default_language = projectConfig["PROJECT"].get(
"default_language", "en-US")
self.logger_api = logger_api
self.DALDatabase.define_table(
'auth_user',
Field('first_name',
'string',
notnull=True,
requires=IS_NOT_EMPTY(),
phanterpwa={
'group': 'group1',
'_class': 'p-col w1p100 w4p70 e-float_right'
}),
Field('last_name',
'string',
notnull=True,
requires=IS_NOT_EMPTY(),
phanterpwa={
'group': 'group1',
'_class': 'p-col w1p100 w4p70 e-float_right'
}),
Field('email',
'string',
notnull=True,
unique=True,
phanterpwa={
'group': 'group1',
'_class': 'p-col w1p100 w4p70 e-float_right'
}),
Field('email_activated', 'boolean', default=False),
Field('fone_number', 'string', phanterpwa={'out_of_form': True}),
Field('fone_number_activated', 'boolean', default=False),
Field('password_hash',
'string',
notnull=True,
requires=IS_NOT_EMPTY(),
phanterpwa={'out_of_form': True}),
Field('login_attempts', 'integer', default=0),
Field(
'datetime_next_attempt_to_login',
'datetime',
requires=IS_EMPTY_OR(IS_DATETIME()),
phanterpwa={
'validators':
['IS_EMPTY_OR', 'IS_DATETIME:yyyy-MM-dd HH:mm:ss'],
# '_class': 'p-col w1p100 w4p40',
# 'section': 'Identidade'
}),
Field('temporary_password',
'text',
phanterpwa={'out_of_form': True}), # it's used in the debug
Field('temporary_password_hash',
'text',
phanterpwa={'out_of_form': True}),
# datetime_next_attempt_to_login
Field('temporary_password_expire',
'datetime',
requires=IS_EMPTY_OR(IS_DATETIME()),
phanterpwa={
'validators':
['IS_EMPTY_OR', 'IS_DATETIME:yyyy-MM-dd HH:mm:ss']
}),
Field('timeout_to_resend_temporary_password_mail',
'datetime',
requires=IS_EMPTY_OR(IS_DATETIME()),
phanterpwa={
'validators':
['IS_EMPTY_OR', 'IS_DATETIME:yyyy-MM-dd HH:mm:ss']
}),
Field('activation_code_by_mobile', 'string', default=0),
Field('activation_code', 'string', default=0),
Field('activation_attempts', 'integer', default=0),
Field('timeout_to_resend_activation_email',
'datetime',
requires=IS_EMPTY_OR(IS_DATETIME()),
phanterpwa={
'validators':
['IS_EMPTY_OR', 'IS_DATETIME:yyyy-MM-dd HH:mm:ss']
}),
# wait_time_to_try_activate_again
Field('datetime_next_attempt_to_activate',
'datetime',
requires=IS_EMPTY_OR(IS_DATETIME()),
phanterpwa={
'validators':
['IS_EMPTY_OR', 'IS_DATETIME:yyyy-MM-dd HH:mm:ss']
}),
Field('permit_mult_login', 'boolean', default=True),
Field('activated', 'boolean', default=False, notnull=True),
Field('websocket_opened',
'boolean',
default=False,
notnull=True,
phanterpwa={'out_of_form': True}),
Field('locale', 'string', default=default_language),
Field('two_factor_login', 'boolean', default=False))
def delete_upload_folder(s):
upload_folder = os.path.join(projectConfig["PROJECT"]["path"],
"backapps", "api", "uploads")
target = os.path.join(upload_folder,
"user_{0}".format(s.select().first().id))
if os.path.exists(target) and os.path.isdir(target):
try:
shutil.rmtree(target)
except Exception:
if self.logger_api:
self.logger_api.error(
"Problem on delete folder: \"{0}\"".format(target),
exc_info=True)
else:
if self.logger_api:
self.logger_api.warning(
"Ther folder \"{0}\" not exists".format(target))
self.DALDatabase.auth_user._before_delete.append(
lambda s: delete_upload_folder(s))
self.DALDatabase.auth_user.email.requires = [
IS_EMAIL(),
IS_NOT_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user.email,
error_message="Email already in database.")
]
self.DALDatabase.auth_user.fone_number.requires = [
IS_EMPTY_OR(
IS_NOT_IN_DB(
self.DALDatabase,
self.DALDatabase.auth_user.fone_number,
error_message="Mobile number already in database."))
]
self.DALDatabase.define_table('auth_group', Field('role', 'string'),
Field('grade', 'integer', default=0),
Field('description', 'text'))
self.DALDatabase.define_table(
'auth_membership',
Field('auth_user',
'reference auth_user',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('auth_group',
'reference auth_group',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_group)))
self.DALDatabase.define_table(
'auth_activity',
Field('auth_user',
'reference auth_user',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('request', 'text'), Field('activity', 'string'),
Field('date_activity', 'datetime', default=datetime.now()))
self.DALDatabase.define_table(
'email_user_list',
Field('auth_user',
'reference auth_user',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('email', 'string', notnull=True),
Field('datetime_changed', 'datetime', default=datetime.now()))
self.DALDatabase.define_table(
'social_auth', Field('social_name', 'string'),
Field('request_state', 'text'), Field('client_token', 'text'),
Field('datetime_created', 'datetime', default=datetime.now()),
Field('origin', 'text'), Field('used', 'boolean', default=False),
Field('user_credentials', 'text'))
self.DALDatabase.define_table(
'two_factor_login',
Field('auth_user',
'reference auth_user',
requires=IS_IN_DB(self.DALDatabase,
self.DALDatabase.auth_user)),
Field('two_factor_url', 'text'), Field('two_factor_code'),
Field('datetime_changed', 'datetime', default=datetime.now()))
self.DALDatabase.email_user_list.email.requires = [IS_EMAIL()]
if self.DALDatabase(self.DALDatabase.auth_group).isempty():
self.DALDatabase.auth_group.insert(
role="root",
grade=100,
description="Administrator of application (Developer)")
self.DALDatabase.auth_group.insert(
role="administrator",
grade=10,
description="Super user of site")
self.DALDatabase.auth_group.insert(role="user",
grade=1,
description="Default user")
self.DALDatabase.commit()
if self.DALDatabase(self.DALDatabase.auth_membership).isempty():
if self.DALDatabase.auth_user[1]:
id_role = self.DALDatabase(self.DALDatabase.auth_group.role ==
'root').select().first()
if id_role:
self.DALDatabase.auth_membership.insert(
auth_user=1, auth_group=id_role.id)
self.DALDatabase.commit()
