def index_process_request_vars(var=None):
"""
This function takes the request.vars as a argument and
"""
from general_helpers import get_last_day_month
from general_helpers import datestr_to_python
today = TODAY_LOCAL
if 'date_from' in request.vars:
date_from = datestr_to_python(DATE_FORMAT, request.vars['date_from'])
elif not session.reports_tax_summary_index_date_from is None:
date_from = session.reports_tax_summary_index_date_from
else:
date_from = datetime.date(
today.year,
today.month,
1
)
session.reports_tax_summary_index_date_from = date_from
if 'date_until' in request.vars:
date_until = datestr_to_python(DATE_FORMAT, request.vars['date_until'])
elif not session.reports_tax_summary_index_date_until is None:
date_until = session.reports_tax_summary_index_date_until
else:
date_until = get_last_day_month(today)
session.reports_tax_summary_index_date_until = date_until
def payment_fixed_rate_class_add():
"""
Add customers to attendance for a class
"""
from openstudio.os_customer import Customer
from openstudio.os_customers import Customers
from general_helpers import datestr_to_python
response.view = 'general/only_content.html'
teID = request.vars['teID']
customer = Customer(teID)
response.title = customer.get_name()
response.subtitle = T("Add class payment rate")
if 'date' in request.vars:
date = datestr_to_python(DATE_FORMAT, request.vars['date'])
else:
date = TODAY_LOCAL
customers = Customers()
result = customers.classes_add_get_form_date(teID, date)
form = result['form']
form_date = result['form_styled']
db.classes.id.readable = False
# list of classes
grid = customers.classes_add_get_list(date, 'tp_fixed_rate', teID=teID)
back = os_gui.get_button('back',
URL('payment_fixed_rate', vars={'teID': teID}),
_class='left')
return dict(content=DIV(form_date, grid), back=back)
def customers_memberships_extend_validity(self, valid_on, days_to_add):
"""
Add "days_to_add" days to cards valid on "valid_on".
:param valid_on: datetime.date
:param days_to_add: int
:return: String: How many cards were updated
"""
from general_helpers import datestr_to_python
db = current.db
DATE_FORMAT = current.DATE_FORMAT
# convert input string to date obj
valid_on = datestr_to_python(DATE_FORMAT, valid_on)
query = (db.customers_memberships.Enddate >= valid_on)
nr_memberships_updated = 0
rows = db(query).select(db.customers_memberships.ALL)
for row in rows:
row.Enddate = row.Enddate + datetime.timedelta(
days=int(days_to_add))
row.update_record()
nr_memberships_updated += 1
##
# For scheduled tasks db connection has to be committed manually
##
db.commit()
return "Updated the expiration date for %s memberships" % nr_memberships_updated
def classes():
"""
Function returns a list of classes today
"""
locID = request.vars['locID']
# Set today while looking at configured timezone
now = pytz.utc.localize(datetime.datetime.now())
tz = pytz.timezone(TIMEZONE)
local_dt = now.astimezone(tz)
today = datetime.date(local_dt.year, local_dt.month, local_dt.day)
date_formatted = today.strftime(DATE_FORMAT)
date = datestr_to_python(DATE_FORMAT, date_formatted)
pretty_date = date.strftime('%B %d, %Y')
location = db.school_locations(locID)
# go_back
response.back = A(SPAN(_class='glyphicon glyphicon-chevron-left'),
_href=URL('index'),
_class='pull-right')
response.title = location.Name
response.subtitle = SPAN(T('Classes'), ' ', ' ', pretty_date)
response.view = 'selfcheckin/default.html'
response.logout = get_logout()
cs = ClassSchedule(date, filter_id_school_location=locID)
rows = cs.get_day_rows()
header = THEAD(TR(
TH(T('Time')),
TH(T('Class type')),
TH(),
))
table = TABLE(header, _class='table table-striped table-hover')
for i, row in enumerate(rows):
repr_row = list(rows[i:i + 1].render())[0]
time = repr_row.classes.Starttime + ' - ' + repr_row.classes.Endtime
link = os_gui.get_button('noicon',
URL('checkin',
vars={
'clsID': row.classes.id,
'date': date_formatted
}),
title=T("Go to check-in"),
_class='pull-right')
tr = TR(TD(time), TD(repr_row.classes.school_classtypes_id), TD(link))
table.append(tr)
return dict(content=table, logout=get_logout())
def checkin_booking_options():
"""
List booking options for a customer
"""
cuID = request.vars['cuID']
clsID = request.vars['clsID']
date_formatted = request.vars['date']
date = datestr_to_python(DATE_FORMAT, date_formatted)
customer = Customer(cuID)
cls = Class(clsID, date)
starttime = cls.cls.Starttime.strftime(TIME_FORMAT)
pretty_date = date.strftime('%B %d, %Y')
classtype = db.school_classtypes(cls.cls.school_classtypes_id)
location = db.school_locations(cls.cls.school_locations_id)
response.title = T(classtype.Name)
response.subtitle = SPAN(starttime, ' ', pretty_date)
response.view = 'selfcheckin/checkin.html'
return_url = URL('selfcheckin',
'checkin',
vars={
'clsID': clsID,
'date': date_formatted
})
cls = Class(clsID, date)
ah = AttendanceHelper()
options = ah.get_customer_class_booking_options_formatted(
clsID,
date,
customer,
trial=True,
list_type='selfcheckin',
controller='classes')
cancel = os_gui.get_button('noicon',
return_url,
title=T('Cancel'),
btn_size='')
content = DIV(H3(T('Booking options for'),
' ',
customer.row.display_name,
_class='center'),
BR(),
options,
DIV(BR(), cancel, _class="col-md-12 center"),
_class="row")
back = os_gui.get_button('back', return_url)
return dict(content=content, back=back)
def set_date():
"""
Set date for cashbook
:return:
"""
from general_helpers import datestr_to_python
date_formatted = request.vars['date']
date = datestr_to_python(DATE_FORMAT, request.vars['date'])
session.finance_cashbook_date = date
redirect(URL('index'))
def test_fix_extend_validity_with_bad_query():
"""
Function to correct extended validity
:return:
"""
from general_helpers import datestr_to_python
valid_on = request.vars['valid_on']
dont_process_after = request.vars['dont_process_after']
days_to_subtract = request.vars['days_to_subtract']
db = current.db
DATE_FORMAT = current.DATE_FORMAT
# convert input string to date obj
valid_on = datestr_to_python(DATE_FORMAT, valid_on)
dont_process_after = datestr_to_python(DATE_FORMAT, dont_process_after)
left = [
db.school_classcards.on(db.customers_classcards.school_classcards_id ==
db.school_classcards.id)
]
query = (
(db.customers_classcards.Enddate >= valid_on) &
(db.customers_classcards.Startdate < dont_process_after) &
(db.customers_classcards.ClassesTaken < db.school_classcards.Classes))
nr_cards_updated = 0
rows = db(query).select(db.customers_classcards.ALL)
for row in rows:
row.Enddate = row.Enddate - datetime.timedelta(
days=int(days_to_subtract))
row.update_record()
nr_cards_updated += 1
return "Subtracted the expiration date for %s cards" % nr_cards_updated
def get_class_revenue():
"""
:return:
"""
from openstudio.os_reports import Reports
set_headers()
clsID = request.vars['clsID']
date_received = request.vars['date']
date = datestr_to_python("%Y-%m-%d", date_received)
reports = Reports()
return dict(revenue=reports.get_class_revenue_summary(clsID, date))
def get_class_teacher_payment():
"""
:return:
"""
from openstudio.os_class import Class
set_headers()
clsID = request.vars['clsID']
date_received = request.vars['date']
date = datestr_to_python("%Y-%m-%d", date_received)
cls = Class(clsID, date)
return dict(payment=cls.get_teacher_payment())
def get_class_attendance():
"""
List attendance for a class
:return:
"""
from openstudio.os_attendance_helper import AttendanceHelper
clsID = request.vars['clsID']
date_received = request.vars['date']
date = datestr_to_python("%Y-%m-%d", date_received)
set_headers()
ah = AttendanceHelper()
attendance = ah.get_attendance_rows(clsID, date).as_list()
return dict(attendance=attendance)
def get_classes():
"""
List upcoming classes for today
:return:
"""
date_received = request.vars['date']
date = datestr_to_python("%Y-%m-%d", date_received)
set_headers()
from openstudio.os_class_schedule import ClassSchedule
cs = ClassSchedule(date,
# filter_starttime_from=time_from
)
return dict(classes=cs.get_day_list())
def customers_classcards_extend_validity(self, valid_on, days_to_add):
"""
Add "days_to_add" days to cards valid on "valid_on".
:param valid_on: datetime.date
:param days_to_add: int
:return: String: How many cards were updated
"""
from general_helpers import datestr_to_python
db = current.db
DATE_FORMAT = current.DATE_FORMAT
# convert input string to date obj
valid_on = datestr_to_python(DATE_FORMAT, valid_on)
left = [
db.school_classcards.on(
db.customers_classcards.school_classcards_id ==
db.school_classcards.id)
]
query = ((db.customers_classcards.Enddate >= valid_on) &
((db.customers_classcards.ClassesTaken <
db.school_classcards.Classes) |
(db.school_classcards.Unlimited == True)))
nr_cards_updated = 0
rows = db(query).select(db.customers_classcards.ALL, left=left)
for row in rows:
row.Enddate = row.Enddate + datetime.timedelta(
days=int(days_to_add))
row.update_record()
nr_cards_updated += 1
##
# For scheduled tasks db connection has to be committed manually
##
db.commit()
return "Updated the expiration date for %s cards" % nr_cards_updated
def checkin():
"""
Checkin page for self checkin
"""
clsID = request.vars['clsID']
date_formatted = request.vars['date']
date = datestr_to_python(DATE_FORMAT, date_formatted)
session.customers_load_list_search_name = None
session.classes_attendance_signin_back = 'self_checkin'
cls = Class(clsID, date)
starttime = cls.cls.Starttime.strftime(TIME_FORMAT)
pretty_date = date.strftime('%B %d, %Y')
classtype = db.school_classtypes(cls.cls.school_classtypes_id)
location = db.school_locations(cls.cls.school_locations_id)
response.title = T(classtype.Name)
response.subtitle = SPAN(starttime, ' ', pretty_date)
response.logout = A(SPAN(_class='glyphicon glyphicon-chevron-left'),
_href=URL('classes',
vars={'locID': cls.cls.school_locations_id}))
#response.view = 'templates/selfcheckin/checkin.html'
# Check if the class is full
full = cls.get_full()
message = ''
if full:
message = DIV(
BR(),
os_gui.get_alert(
'info',
SPAN(
B(T('Notice')), BR(),
T("This class is full, it's no longer possible to check in"
)),
dismissable=False))
search_results = DIV(LOAD(
'customers',
'load_list.load',
target='attendance_list_customers_list',
content=os_gui.get_ajax_loader(message=T("Searching...")),
vars={
'list_type': 'selfcheckin_checkin',
'items_per_page': 10,
'clsID': clsID,
'date': date_formatted,
'pictures': False
},
ajax=True),
_id="attendance_list_customers_list",
_class="load_list_customers clear")
name = ''
show_subscriptions_prop = 'selfcheckin_show_subscriptions'
show_subscriptions = get_sys_property(show_subscriptions_prop)
if show_subscriptions:
show_subscriptions = True
else:
show_subscriptions = False
ah = AttendanceHelper()
customers = ah.get_checkin_list_customers_booked(
clsID,
date,
pictures=False,
invoices=False,
show_notes=False,
reservations=False,
manage_checkin=False,
show_booking_time=False,
show_subscriptions=show_subscriptions,
class_full=full)
form = checkin_get_search_form(clsID, date, name, request.function)
content = DIV(
SPAN(location.Name, _class='grey'),
message,
customers,
)
if not full:
content.append(
DIV(H2(T("I'm not yet on the list...")), form, search_results))
return dict(content=content)
def list_invoices(self,
cuID=None,
csID=None,
search_enabled=False,
group_filter_enabled=False,
only_teacher_credit_invoices=False,
only_employee_claim_credit_invoices=False):
db = current.db
auth = current.auth
session = current.session
grid_ui = current.globalenv['grid_ui']
DATE_FORMAT = current.DATE_FORMAT
from general_helpers import datestr_to_python
from openstudio.os_gui import OsGui
os_gui = OsGui()
T = current.T
session.invoices_invoice_payment_add_back = None
# disable unused fields
db.invoices.id.readable = False
db.invoices.invoices_groups_id.readable = False
db.invoices.Footer.readable = False
db.invoices.Note.readable = False
db.invoices.Terms.readable = False
db.invoices.TeacherPayment.readable = False
db.invoices.EmployeeClaim.readable = False
links = [
dict(header=T("Balance"), body=self._list_invoices_get_balance),
lambda row: os_gui.get_label('primary', T('Teacher inv'))
if row.invoices.TeacherPayment else '',
self._list_invoices_get_buttons
]
left = [
db.invoices_amounts.on(
db.invoices_amounts.invoices_id == db.invoices.id),
db.invoices_customers.on(
db.invoices_customers.invoices_id == db.invoices.id),
db.auth_user.on(
db.invoices_customers.auth_customer_id == db.auth_user.id)
]
fields = [
db.invoices.Status, db.invoices.InvoiceID, db.invoices.Description,
db.invoices.DateCreated, db.invoices.DateDue,
db.invoices_amounts.TotalPriceVAT, db.invoices.TeacherPayment
]
query = (db.invoices.id > 0)
# Status filter
query = self._list_invoices_get_status_query(query)
if search_enabled:
query = self._list_invoices_get_search_query(query)
if group_filter_enabled:
query = self._list_invoices_get_groups_query(query)
if only_teacher_credit_invoices:
query &= (db.invoices.TeacherPayment == True)
if only_employee_claim_credit_invoices:
query &= (db.invoices.EmployeeClaim == True)
# General list, list for customer or list for subscription
if not cuID and not csID:
# list all invoices
fields.insert(2, db.invoices.CustomerListName)
if cuID:
query &= (db.invoices_customers.auth_customer_id == cuID)
if csID:
left.extend([
db.invoices_items.on(
db.invoices_items.invoices_id == db.invoices.id),
db.invoices_items_customers_subscriptions.on(
db.invoices_items_customers_subscriptions.invoices_items_id
== db.invoices_items.id),
])
query &= (db.invoices_items_customers_subscriptions.
customers_subscriptions_id == csID)
fields.insert(3, db.invoices.SubscriptionMonth)
fields.insert(4, db.invoices.SubscriptionYear)
delete_permission = auth.has_membership(group_id='Admins') or \
auth.has_permission('delete', 'invoices')
grid = SQLFORM.grid(
query,
links=links,
left=left,
field_id=db.invoices.id,
fields=fields,
create=False,
editable=False,
details=False,
searchable=False,
deletable=delete_permission,
csv=False,
# maxtextlengths=maxtextlengths,
orderby=~db.invoices.id,
ui=grid_ui)
grid.element('.web2py_counter', replace=None) # remove the counter
grid.elements('span[title=Delete]',
replace=None) # remove text from delete button
form_search = ''
content = DIV()
if search_enabled:
#response.js = 'set_form_classes();' # we're no longer in a loaded component
request = current.request
if 'search' in request.vars:
session.invoices_list_invoices_search = request.vars['search']
# date_created_from = datestr_to_python(DATE_FORMAT, request.vars['date_created_from'])
# session.invoices_list_invoices_date_created_from = date_created_from
try:
date_created_from = datestr_to_python(
DATE_FORMAT, request.vars['date_created_from'])
session.invoices_list_invoices_date_created_from = date_created_from
except (ValueError, AttributeError):
session.invoices_list_invoices_date_created_from = None
try:
date_created_until = datestr_to_python(
DATE_FORMAT, request.vars['date_created_until'])
session.invoices_list_invoices_date_created_until = date_created_until
except (ValueError, AttributeError):
session.invoices_list_invoices_date_created_until = None
try:
date_due_from = datestr_to_python(
DATE_FORMAT, request.vars['date_due_from'])
session.invoices_list_invoices_date_due_from = date_due_from
except (ValueError, AttributeError):
session.invoices_list_invoices_date_due_from = None
try:
date_due_until = datestr_to_python(
DATE_FORMAT, request.vars['date_due_until'])
session.invoices_list_invoices_date_due_until = date_due_until
except (ValueError, AttributeError):
session.invoices_list_invoices_date_due_until = None
keys = [
'search', 'date_created_from', 'date_created_until',
'date_due_from', 'date_due_until'
]
for key in keys:
try:
del request.vars[key]
except KeyError:
pass
# redirect to update page
redirect(URL(vars=request.vars))
form_search = self._list_invoices_get_form_search()
content.append(form_search)
form_groups = ''
if group_filter_enabled:
if 'invoices_groups_id' in request.vars:
session.invoices_list_invoices_group = request.vars[
'invoices_groups_id']
try:
del request.vars['invoices_groups_id']
except KeyError:
pass
# redirect to update page
redirect(URL(vars=request.vars))
# always add the grid
content.append(grid)
return content
def classes():
"""
List classes in shop
"""
response.view = 'embed/index.html'
if 'date' in request.vars:
start_date = datestr_to_python(DATE_FORMAT, request.vars['date'])
if start_date < TODAY_LOCAL:
start_date = TODAY_LOCAL
else:
start_date = TODAY_LOCAL
# set up filter variables
filter_id_school_location = ''
filter_id_school_classtype = ''
filter_id_school_level = ''
filter_id_teacher = ''
if 'location' in request.vars:
filter_id_school_location = request.vars['location']
if 'teacher' in request.vars:
filter_id_teacher = request.vars['teacher']
if 'classtype' in request.vars:
filter_id_school_classtype = request.vars['classtype']
filter = classes_get_filter(
start_date,
filter_id_school_classtype=filter_id_school_classtype,
filter_id_school_location=filter_id_school_location,
filter_id_school_level='',
filter_id_teacher=filter_id_teacher)
days = []
for day in range(0, 7):
date = start_date + datetime.timedelta(days=day)
classes_list = classes_get_day(
date,
filter_id_school_classtype=filter_id_school_classtype,
filter_id_school_location=filter_id_school_location,
filter_id_school_level='',
filter_id_teacher=filter_id_teacher)
days.append(
dict(date=date, weekday=date.isoweekday(), classes=classes_list))
classes = DIV()
for day in days:
header = H3(
NRtoDay(day['weekday']), ' ',
XML('<small>' + day['date'].strftime('%d %B %Y') + '</small>'))
table_header = DIV(
DIV(SPAN(T('Time')), _class='col-md-2'),
DIV(SPAN(T('Location')), _class='col-md-2'),
DIV(SPAN(T('Class')), _class='col-md-3'),
DIV(SPAN(T('Teacher')), _class='col-md-2'),
DIV(SPAN(T('Spaces')), _class='col-md-1'),
DIV(' ', _class='col-md-2'), # Actions
_class='row shop_classes_table_header bold hidden-xs hidden-sm')
table = DIV(table_header, _class='shop-classes')
for c in day['classes']:
time = SPAN(c['Starttime'], ' - ', c['Endtime'])
sub = ''
if c['Subteacher']:
sub = ' (sub)'
book = classes_get_button_book(c)
table_row = DIV(
DIV(time, _class='col-md-2'),
DIV(c['Location'], _class='col-md-2'),
DIV(c['ClassType'], _class='col-md-3'),
DIV(c['Teacher'], ' ', sub, _class='col-md-2'),
DIV('(',
c['BookingSpacesAvailable'],
')',
_class='col-md-1 grey'),
DIV(DIV(book, _class='pull-right'),
_class='col-md-2'), # Actions
_class='row')
table.append(table_row)
class_day = DIV(
DIV(DIV(header, _class="col-md-12"), _class="row"),
DIV(
DIV(DIV(table, _class="box-body no-padding"),
_class="box box-solid"),
# _class="col-md-12"
),
_class="row")
classes.append(class_day)
return dict(content=DIV(filter, classes))
