def __call__(self):
session = DBSession()
transaction = Transaction()
params = self.request.params
year = int(params['year'])
month = int(params['month'])
if params['ttype_id'] == '--':
return self.redir_to_list(year, month, msg='Please select a type.')
ttype = session.query(TransactionType).get(params['ttype_id'])
transaction.ttype = ttype
transaction.amount = float(params['amount'])
if ttype.mem_sup == 'memb' and 'mem_id' in params:
transaction.member = session.query(Member).get(params['mem_id'])
if ttype.mem_sup == 'whol' and 'wh_id' in params:
transaction.wholesaler = session.query(Wholesaler).get(
params['wh_id'])
if ttype.mem_sup == 'vers' and 'vers_id' in params:
transaction.vers_supplier = session.query(VersSupplier).get(
params['vers_id'])
transaction.comment = params['comment']
if 'ord_no' in params and not params['ord_no'] in ('', '--'):
transaction.ord_no = int(params['ord_no'])
if 'late' in params:
transaction.late = bool(params['late'])
day = int(params['day'])
adate = datetime.date(year, month, day)
transaction.date = adate
transaction.validate()
session.add(transaction)
session.flush()
return self.redir_to_list(year, month, msg='Transaction "{}" has been '\
'added to the list.'.format(str(transaction)))
def __call__(self):
name = self.request.params['name']
pos_neg = self.request.params['pos_neg']
mem_sup = self.request.params['mem_sup']
tt = TransactionType(None, name=name, pos_neg=pos_neg, mem_sup=mem_sup)
tt.validate()
session = DBSession()
existing = session.query(TransactionType)\
.filter(TransactionType.name == tt.name).all()
if len(existing) > 0:
return self.redirect('/transaction-types?msg=Transaction type '\
' with name "{}" already exists'\
.format(tt.name))
session.add(tt)
session.flush()
return self.redirect('/transaction-types?msg=Transaction type "{}"'\
' has been added to the list.'.format(tt.name))
def __call__(self):
session = DBSession()
member = get_member(session, self.request)
self.user_may_edit_admin_settings = (
self.user.mem_admin and not self.user.mem_id == member.mem_id)
if 'action' in self.request.params:
action = self.request.params['action']
if action == "save":
member = fill_member_from_request(
member, self.request, self.user_may_edit_admin_settings)
member.validate()
if not member.exists:
session.add(member)
session.flush() # flush manually so the member gets an ID
send_pwdreset_request(member,
self.request.application_url,
first=True)
return self.redirect('/member/{0:d}?msg=Member has been'\
' created and got an email to set up'\
' a password. Note: no membership'\
' fee has been charged (we do not'\
' know the household size).'\
.format(member.mem_id))
return dict(m=member, msg='Member has been saved.')
elif action == 'toggle-active':
member = get_member(session, self.request)
self.confirm_toggle_active = True
return dict(m=member)
elif action == 'toggle-active-confirmed':
member.mem_active = not member.mem_active
msg='Member {} is now {}active.'.\
format(member, {False:'in', True:''}[member.mem_active])
if not member.mem_active and not running_sqlite():
query = "select remove_inactive_member_order({});"\
.format(member.mem_id)
try:
session.connection().engine.execute(query)
except:
msg += ' Warning: Their current order could not be removed,'\
' (e.g. because it has already been sent to suppliers)'\
' so the member will probably still need to pay.'
return dict(m=member, msg=msg)
return dict(m=member, msg='')
def __call__(self):
session = DBSession()
a_id = self.request.matchdict['a_id']
applicant = get_applicant(session, a_id)
# copy over our knowledge of him/her
member = Member(self.request, applicant.fname, '', applicant.lname)
now = datetime.now()
txt = "Joined orientation in {}, became member in {}/{}.".format(\
applicant.month, now.month, now.year)
member.mem_adm_comment = "{}\n{}".format(txt, applicant.comment)
member.mem_email = applicant.email
member.mem_home_tel = applicant.telnr
member.mem_household_size = applicant.household_size
member.validate()
session.add(member)
session.delete(applicant)
session.flush()
send_pwdreset_request(member, self.request.application_url, first=True)
return self.redirect("/member/{}?msg=Applicant has been made "\
"into a new Member and got an email to set up a "\
"password."\
.format(member.mem_id))
def __call__(self):
fname = self.request.params['fname']
lname = self.request.params['lname']
now = datetime.now()
month = "{}/{}".format(
str(now.month).rjust(2, '0'),
str(now.year)[-2:])
comment = self.request.params['comment']
email = self.request.params['email']
telnr = self.request.params['telnr']
if not self.request.params['household_size'].isdigit():
raise VokoValidationError(
"Please enter valid household size (number > 1), not: '%s'" %
self.request.params['household_size'])
hsize = int(self.request.params['household_size'])
applicant = Applicant(None, fname, lname, month, comment, email, telnr,
hsize)
applicant.validate()
session = DBSession()
session.add(applicant)
session.flush()
return dict(applicants=get_applicants(session),
msg="Applicant has been added to the list.")
def __call__(self):
session = DBSession()
wg = get_wg(session, self.request)
req = self.request
self.possible_members = get_possible_members(session, wg)
if 'action' in req.params:
action = req.params['action']
if action == "save":
old_name = wg.name
uwgs = [w.name for w in self.user.workgroups]
wg = fill_wg_from_request(wg, req, session)
if wg.exists and not wg.name == old_name\
and not 'Systems' in uwgs:
raise Exception('Only members of Systems can change the'\
' name of an existing workgroup, because'\
' it changes the email addresses of the'\
' group.')
wg.validate()
if not wg.exists:
session.add(wg)
session.flush() # flushing manually so the wg gets an ID
return self.redirect('/workgroup/%d?msg='\
'Workgroup was created.' % wg.id)
return dict(wg=wg, msg='Workgrup has been saved.')
elif action == 'toggle-active':
wg = get_wg(session, self.request)
self.confirm_toggle_active = True
return dict(wg=wg)
elif action == 'toggle-active-confirmed':
wg.active = not wg.active
msg='Workgroup {} is now {}active.'.\
format(wg.name, {False:'in', True:''}[wg.active])
return dict(wg=wg, msg=msg)
return dict(wg=wg, msg='')
def __call__(self):
'''
Create order charges for a given order in the system
'''
o_id = int(self.request.matchdict['o_id'])
session = DBSession()
order = session.query(Order).\
filter(Order.id == o_id).first()
if not order:
return dict(msg='An order with ID {} does not exist.'.format(o_id),
order=None, action=None)
charge_ttype_id = get_ttypeid_by_name('Order Charge')
if not 'Finance' in [wg.name for wg in self.user.workgroups]\
and not self.user.mem_admin:
return dict(order=order, action=None,
msg='Only Finance people can do this.')
# all (positive) charges for members who have not been charged for
# this order yet
charges = [MemberOrder(m, order) for m in session.query(Member).all()]
charges = [c for c in charges if c.amount > 0 and not o_id in\
[t.order.id for t in c.member.transactions\
if t.ttype_id == charge_ttype_id]]
first_orderers = []
if not 'action' in self.request.params:
# show charges that would be made
return dict(order=order, action='show', charges=charges)
else:
# temporary backdoor to test this
if self.request.params['action'] == 'gggraph':
orders_money_and_people()
if self.request.params['action'] == 'charge':
# confirmation: make charges
for c in charges:
t = Transaction(amount = -1 * c.amount,
comment = 'Automatically charged.'
)
ttype = session.query(TransactionType)\
.get(charge_ttype_id)
t.ttype = ttype
t.member = c.member
t.order = c.order
t.validate()
session.add(t)
# first order of this member? Charge Membership fee
if c.is_first_order():
first_orderers.append(c.member)
mf = Transaction(\
amount = membership_fee(c.member) * -1,
comment = 'Automatically charged (for {}'\
' people in the household) on first-time'\
' order ({})'\
.format(c.member.mem_household_size,
c.order.label)
)
ttype = session.query(TransactionType)\
.get(get_ttypeid_by_name('Membership Fee'))
mf.ttype = ttype
mf.member = c.member
mf.validate()
session.add(mf)
# use this opportunity to update graph data
orders_money_and_people()
# inform membership about people who ordered for first time
subject = 'First-time orderers'
body = 'FYI: Below is a list of people who ordered for the'\
' first time today. This mail was auto-generated.\n\n'
body += '\n'.join(['{} [ID:{}]'.format(ascii_save(m.fullname), m.mem_id)\
for m in first_orderers])
sendmail('*****@*****.**', subject, body,
folder='order-charges/{}'.format(o_id),
sender='*****@*****.**')
return dict(order=order, action='done')
return dict(order=order, action='')
