def maketag(tbl, ttf, flf, txt):
"""docstring for maketag"""
tbl = tbl if isinstance(tbl, list) else [tbl]
mytbl = [db[t] for t in tbl if t in db.tables]
if not mytbl:
return False
url = URL('plugin_markmin_extras', 'download',
mytbl(mytbl[ttf] == txt)[mytbl[flf]]).xml()
return url
def add_to_book_button(self):
user = self.session.auth.user if self.session.auth else None
if user:
already = self.db.CookRecipeBook(article_id=int(self.request.args(0)), user_id=user.id)
if already:
bt = BUTTON(self.T("On your book! (remove)"),
_class="button already-on-book",
_onclick="ajax('%s', [], 'addtobookbutton');" % URL('cookrecipe', 'removefrombook', args=self.request.args(0)))
else:
bt = BUTTON(self.T("Add to my book"),
_class="button button not-on-book",
_onclick="ajax('%s', [], 'addtobookbutton');" % URL('cookrecipe', 'addtobook', args=self.request.args(0)))
else:
bt = BUTTON(self.T("Add to my book"),
_class="button button not-on-book",
_onclick="window.location = '%s';" % URL('default', 'user',
args='login', vars=dict(_next=self.CURL('article', 'show', args=self.request.args(0)))))
return bt
def exception_handler():
import sys, traceback
etype, value, tb = sys.exc_info()
error = ''
msg = ''.join(traceback.format_exception(etype, value, tb, 10))
if is_moderator():
error = msg
logger.error(msg)
redirect(URL(c='default', f='error',vars={'error':error}))
def gen_links(row):
diff = A(
SPAN(_class="glyphicon glyphicon-random"),
_href=URL('diff', args=[item.unique_id, row.id]),
_class="btn btn-default",
_title=T("Differences"),
)
return CAT(diff)
def customise_event_incident_report_controller(**attr):
from gluon import A
s3 = current.response.s3
# Custom prep
standard_prep = s3.prep
def custom_prep(r):
# Call standard postp
if callable(standard_prep):
result = standard_prep(r)
if not result:
return False
if r.method in (None, "create"):
current.s3db.gis_location.addr_street.label = T(
"Street Address or Location Details")
from s3 import S3SQLCustomForm
crud_form = S3SQLCustomForm(
(T("What is it?"), "name"),
"incident_type_id",
(T("Who am I speaking with?"), "reported_by"),
(T("How can we contact you?"), "contact"),
(T("Where did this Incident take place?"), "location_id"),
(T("Explain the Situation?"), "description"),
(T("What are your immediate needs?"), "needs"),
)
r.resource.configure(
create_next=URL(args=["[id]", "assign"]),
crud_form=crud_form,
)
return True
s3.prep = custom_prep
# No sidebar menu
current.menu.options = None
req_args = current.request.args
if len(req_args) > 1 and req_args[1] == "assign":
attr["rheader"] = A(
T("New Incident"),
_class="action-btn",
_href=URL(
c="event",
f="incident",
args=["create"],
vars={"incident_report_id": req_args[0]},
),
)
else:
attr["rheader"] = event_rheader
return attr
def getImage(image):
"""
Gets an image or gets a default image if the image does not exist.
Keyword Arguments:
image -- file path of the image to get
Return Values:
out -- file path of the image
-- file path of a default image if the image does not exist
"""
from gluon import URL
out = URL('static', 'images/default.png')
if image is not None and image is not '':
out = URL('default', 'download', args=image)
return out
def ICONLINK(user, icon, text, action=None, title="Click", theme_name="basic"):
from gluon import current
request = current.request
bt = A(_class="icon-link",
_onclick=action if user else "window.location = '%s'" %
URL('default',
'user',
args='login',
vars=dict(_next=URL('article', 'show', args=request.args))),
_style="cursor:pointer;",
_title=title)
bt.append(
CAT(
IMG(_src=URL('static',
'%s/images/icons' % theme_name,
args="%s.png" % icon),
_width=16), SPAN(text, _style="line-height:16px;")))
return bt
def __init__(self, user_id):
self.user_id = user_id
self.card_title = "Upcoming contests"
self.cache_key = CARD_CACHE_REDIS_KEYS["upcoming_contests"]
self.ctas = [
dict(btn_text="View all",
btn_url=URL("default", "contests"),
btn_class="upcoming-contests-card-view-all")
]
BaseCard.__init__(self, self.user_id)
def __init__(self, user_id):
self.user_id = user_id
self.card_title = "Support StopStalk!"
self.stats = None
self.ctas = [
dict(btn_url=URL("default", "support_us"),
btn_text="Show",
btn_class="support-us-card-show")
]
BaseCard.__init__(self, user_id)
def incident_name(row):
return A(
row["event_incident.name"],
_href=URL(
c="event",
f="incident",
args=[row["event_incident.id"], "custom"],
extension="", # ensure no .aadata
),
)
def create_new(self):
# permission is checked here
if self.auth.has_membership("author", self.auth.user_id):
self.db.Post.author.default = self.auth.user_id
self.context.form = SQLFORM(
self.db.Post,
formstyle='divs').process(onsuccess=lambda form: redirect(
URL('show', args=form.vars.id)))
else:
self.context.form = "You can't post, only logged in users, members of 'author' group can post"
def hr_name(row):
hr_id = row["event_human_resource.human_resource_id"]
return A(
hr_represent(hr_id),
_href=URL(
c="event",
f=f,
args=[record_id, "human_resource", hr_id, "profile"],
),
)
def team_name(row):
group_id = row["event_team.group_id"]
return A(
group_represent(group_id),
_href=URL(
c="event",
f=f,
args=[record_id, "group", group_id, "profile"],
extension="", # ensure no .aadata
),
)
def redirection(url=None):
session = current.session
request = current.request
_next = session._next or request.vars._next
if _next:
session._next = None
redirect(_next)
elif url:
redirect(url)
else:
redirect(URL('default', 'index'))
def task_name(row):
return A(
row["project_task.name"],
_href=URL(
c="event",
f=f,
args=[
record_id, "task", row["project_task.id"], "profile"
],
),
)
def customise_event_incident_controller(**attr):
s3db = current.s3db
s3 = current.response.s3
# Load default model, so we can over-ride
s3db.event_incident
from gluon import URL
s3db.configure("event_incident",
create_next = URL(c="event", f="incident",
args=["[id]", "plan"]),
)
# Custom prep
standard_prep = s3.prep
def custom_prep(r):
# Call standard postp
if callable(standard_prep):
result = standard_prep(r)
if r.method == "create":
incident_report_id = r.get_vars.get("incident_report_id")
if incident_report_id:
if r.http == "GET":
from s3 import s3_truncate
rtable = s3db.event_incident_report
incident_report = current.db(rtable.id == incident_report_id).select(rtable.name,
rtable.incident_type_id,
rtable.location_id,
limitby = (0, 1),
).first()
table = r.table
table.name.default = s3_truncate(incident_report.name, 64)
table.incident_type_id.default = incident_report.incident_type_id
table.location_id.default = incident_report.location_id
elif r.http == "POST":
def create_onaccept(form):
s3db.event_incident_report_incident.insert(incident_id = form.vars.id,
incident_report_id = incident_report_id,
)
r.resource.configure(create_onaccept = create_onaccept,
)
return True
s3.prep = custom_prep
# No sidebar menu
current.menu.options = None
attr["rheader"] = event_rheader
return attr
def __init__(self, user_id):
self.user_id = user_id
self.card_title = "Link more accounts"
self.cache_key = CARD_CACHE_REDIS_KEYS["more_accounts_prefix"] + str(
self.user_id)
self.ctas = [
dict(btn_text="Update now",
btn_url=URL("user", "update_details"),
btn_class="linked-accounts-card-update-now")
]
BaseCard.__init__(self, user_id)
def set_paging(self):
self.page = (int(self._request.vars["page"] or 0))
self.items_per_page = int(
self._request.vars["per"] if int(self._request.vars["per"] or -1)
in Paginater.item_limits else Paginater.item_limits[1])
self.limitby = (self.page * self.items_per_page,
(self.page + 1) * self.items_per_page) # 1*5 <-> 2*5+1
for each in self.item_limits:
href = URL(args=self._request.args,
vars=dict(self._old_vars + {
'per': each,
'page': 0
}.items()))
self.items_per_page_urls.append(
dict(href=href,
number=each,
current=each == self.items_per_page))
self.item_count = self._query_set.count()
division = self.item_count / float(self.items_per_page)
self.pages = int(math.floor(
division)) # don't need a new page for not full pages ie. 11/12
if division % 1 == 0: # fixed - there may be a bug with left inner join as not all left from (db.table>0) will show up if right is missing, use left outer join instead.
self.pages -= 1 # don't need a new page for a full page ie. 12/12 items
for each in xrange(self.pages + 1): # xrange doesn't include last
href = URL(args=self._request.args,
vars=dict(self._old_vars + {'page': each}.items()))
self.page_urls.append(
dict(href=href, number=each, current=each == self.page))
self.has_next = self.page < self.pages # need a new page for overfull page ie. 13/12 items, need page for 1/12
self.has_prev = bool(self.page)
self.next_page = None if not self.has_next else self.page + 1 # href='{{=URL(vars=dict(page=paginater.next_page))}}'
self.next_url = URL(args=self._request.args,
vars=dict(self._old_vars +
{'page': self.next_page}.items()))
self.prev_page = None if not self.has_prev else self.page - 1
self.prev_url = URL(args=self._request.args,
vars=dict(self._old_vars +
{'page': self.prev_page}.items()))
def _():
# shortcuts
# useful links to internal and external resources
response.menu += [(SPAN('web2py', _style='color:yellow'), False, None, [
(T('This App'), False, URL('admin', 'default', 'design/%s' % app), [
(T('Controller'), False,
URL('admin', 'default',
'edit/%s/controllers/%s.py' % (app, ctr))),
(T('View'), False,
URL('admin', 'default',
'edit/%s/views/%s' % (app, response.view))),
(T('Layout'), False,
URL('admin', 'default', 'edit/%s/views/layout.html' % app)),
(T('Stylesheet'), False,
URL('admin', 'default', 'edit/%s/static/css/web2py.css' % app)),
(T('DB Model'), False,
URL('admin', 'default', 'edit/%s/models/db.py' % app)),
(T('Menu Model'), False,
URL('admin', 'default', 'edit/%s/models/menu.py' % app)),
(T('Database'), False, URL(app, 'appadmin', 'index')),
(T('Errors'), False, URL('admin', 'default', 'errors/' + app)),
(T('About'), False, URL('admin', 'default', 'about/' + app)),
]),
('web2py.com', False, 'http://www.web2py.com', [
(T('Download'), False,
'http://www.web2py.com/examples/default/download'),
(T('Support'), False,
'http://www.web2py.com/examples/default/support'),
(T('Demo'), False, 'http://web2py.com/demo_admin'),
(T('Quick Examples'), False,
'http://web2py.com/examples/default/examples'),
(T('FAQ'), False, 'http://web2py.com/AlterEgo'),
(T('Videos'), False,
'http://www.web2py.com/examples/default/videos/'),
(T('Free Applications'), False, 'http://web2py.com/appliances'),
(T('Plugins'), False, 'http://web2py.com/plugins'),
(T('Layouts'), False, 'http://web2py.com/layouts'),
(T('Recipes'), False, 'http://web2pyslices.com/'),
(T('Semantic'), False, 'http://web2py.com/semantic'),
]),
])]
def ensure_image_url(self, url):
if url.startswith("http"):
return url
else:
parts = url.split("/")
return URL(parts[1],
parts[2],
parts[3],
args=parts[4:],
scheme=True,
host=True,
extension=False)
def get_user(self):
""" Returns the user info """
token = self.accessToken()
if not token:
return None
session = current.session
user = None
try:
user = self.call_api(token)
except Exception:
session.token = None
user_dict = None
if user:
#if "email" not in user:
# # Non-standard key for "email" claim
# email = user.get("mail")
#else:
email = user.get("email")
if not email:
msg = "OpenID Connect: unidentifiable user %s" % user.get(
"sub")
current.session.warning = msg
current.log.warning(msg)
redirect(URL(c="default", f="user", args=["login"]))
# Check if a user with this email has already registered
table = current.auth.settings.table_user
query = (table.email == email)
existing = current.db(query).select(table.id,
table.password,
limitby=(0, 1)).first()
if existing:
user_dict = {"email": email, "password": existing.password}
else:
first_name = user.get("given_name", "")
last_name = user.get("family_name", "")
if not first_name and not last_name and "name" in user:
# Try to parse the combined 'name' field
from nameparser import HumanName
name = HumanName(user.get("name", ""))
first_name = name.first
last_name = name.last
user_dict = {
"first_name": first_name,
"last_name": last_name,
"email": email,
}
return user_dict
def prep(r):
# Call standard prep
result = standard_prep(r) if callable(standard_prep) else True
table = r.table
context = r.get_vars.get("resource")
if context == "Privacy":
page = URL(c="default", f="index", args=["privacy"])
r.resource.configure(
create_next=page,
update_next=page,
)
table.name.default = "Privacy Notice"
elif context == "Legal":
page = URL(c="default", f="index", args=["legal"])
r.resource.configure(
create_next=page,
update_next=page,
)
table.name.default = "Legal Notice"
return result
def __init__(self, user_id):
self.user_id = user_id
self.card_title = "Looking for job!"
self.cache_key = CARD_CACHE_REDIS_KEYS["job_profile_prefix"] + str(
self.user_id)
self.ctas = [
dict(btn_text="Update job preferences",
btn_url=URL("default", "job_profile"),
btn_class="job-profile-card-update-preferences")
]
BaseCard.__init__(self, user_id)
def informe_mes_empleado():
empleados = db(db.empleado.is_active is True).select(db.empleado.ALL)
fempl = ([" "] +
[f"{p.user_code} {p.nombre} {p.apellido}" for p in empleados])
form = FORM(
CENTER(
H4('Marcadas del personal'),
TABLE(
TR(
TAG('<label class "control-label">Persona</label>'),
SELECT(fempl,
_name='fempleado',
_type='text',
_id="persona",
_class="form-control string")),
TR(
TAG('<label class "control-label">Periodo desde</label>'),
INPUT(_name='fdesde',
_type='date',
_id="mesanio",
_class="form-control string",
requires=IS_NOT_EMPTY())),
TR(
TAG('<label class "control-label">Periodo hasta</label>'),
INPUT(
_name='fhasta',
_type='date',
_id="mesanio",
_class="form-control string",
))), BR(),
INPUT(_type="submit",
_class="btn btn-primary btn-medium",
_value='Continuar')))
if form.accepts(request, session):
session.empleado = request.vars['fempleado']
session.user_code = request.vars['fempleado'].split()[0]
session.fdesde = request.vars['fdesde']
session.fhasta = request.vars['fhasta']
log(f"seleccionado {session.empleado}")
log(f"desde: {session.fdesde} hasta {session.fhasta}")
# selector = (db.empleado.user_code == user_code)
# usuario = db(selector).select().first().as_dict()
session.tdesde = datetime.datetime.strptime(session.fdesde, '%Y-%m-%d')
session.thasta = datetime.datetime.strptime(session.fhasta, '%Y-%m-%d')
lista = aplico_politica(session.user_code, session.fdesde,
session.fhasta)
nombre_archivo = f'''{session.empleado}
-{session.fdesde}-{session.fhasta}'''
session.table = list_dict_to_table_sortable(lista, nombre_archivo)
redirect(URL('informe'))
else:
log(f'acceso {request.function}')
return dict(form=form)
def link(self, k, v, row=None):
"""
Represent a (key, value) as hypertext link
@param k: the key (br_case_activity.id)
@param v: the representation of the key
@param row: the row with this key
"""
url = URL(c = "vol", f = "person", args = [row.id], extension = "")
return A(v, _href = url)
def custom_prep(r):
# Call standard postp
if callable(standard_prep):
result = standard_prep(r)
if r.method == "create" and r.http == "POST":
from gluon import URL
r.resource.configure(create_next=URL(c="event",
f="scenario",
args=["[id]", "plan"]), )
return True
def edit():
desk = db.desk(request.args(0))
session.desk_id = desk.id
db.desk.item_list.readable = False
db.desk.item_list.writable = False
form = SQLFORM(db.desk, record=desk, showid=False)
if form.process().accepted:
redirect(URL('index', args=[desk.id]))
return locals()
def menu_personal(cls):
""" Personal Menu """
auth = current.auth
#s3 = current.response.s3
settings = current.deployment_settings
ADMIN = current.auth.get_system_roles().ADMIN
if not auth.is_logged_in():
request = current.request
login_next = URL(args=request.args, vars=request.vars)
if request.controller == "default" and \
request.function == "user" and \
"_next" in request.get_vars:
login_next = request.get_vars["_next"]
self_registration = settings.get_security_self_registration()
menu_personal = MP()(
MP("Register", c="default", f="user",
m = "register",
check = self_registration,
),
MP("Login", c="default", f="user",
m = "login",
vars = {"_next": login_next},
),
)
if settings.get_auth_password_retrieval():
menu_personal(MP("Lost Password", c="default", f="user",
m = "retrieve_password",
),
)
else:
s3_has_role = auth.s3_has_role
is_org_admin = lambda i: not s3_has_role(ADMIN) and \
s3_has_role("ORG_ADMIN")
menu_personal = MP()(
MP("Administration", c="admin", f="index",
restrict = ADMIN,
),
MP("Administration", c="admin", f="user",
check = is_org_admin,
),
MP("Profile", c="default", f="person"),
MP("Change Password", c="default", f="user",
m = "change_password",
),
MP("Logout", c="default", f="user",
m = "logout",
),
)
return menu_personal
def org_name(row):
organisation_id = row["event_organisation.organisation_id"]
return A(
org_represent(organisation_id),
_href=URL(
c="event",
f=f,
args=[
record_id, "organisation", organisation_id, "profile"
],
),
)
def approve_user(r, **args):
from gluon import redirect
db = current.db
user = db(db.auth_user.id == r.id).select(limitby=(0, 1)).first()
org_group_id = user.org_group_id
if org_group_id:
# Check if this is a COVID-19 Test Station
ogtable = current.s3db.org_group
org_group = db(ogtable.id == org_group_id).select(
ogtable.name, limitby=(0, 1)).first()
if org_group and org_group.name == TESTSTATIONS:
# Custom Approval process
redirect(
URL(c="default", f="index", args=["approve", r.id]))
# Default Approval
auth.s3_approve_user(user)
current.session.confirmation = T("User Account has been Approved")
redirect(URL(args=[r.id, "roles"]))
