def send_invitation(event,user,invitation):
#invitation email with registration link
subject = settings.TEMPLATE_CONTENT['events']['email']['subject'] % { 'title': unicode(event.title) }
message_content = {
'FULLNAME' : gen_fullname(user),
'MESSAGE' : unicode(invitation.message),
}
#send email
try:
return notify_by_email(user.email,subject,message_content,False,settings.MEDIA_ROOT + unicode(invitation.attachement))
except:
return notify_by_email(user.email,subject,message_content)
def generate_invoice(m,year=date.today().strftime('%Y')):
from members.models import Member
INV = settings.ACCOUNTING['invoice']
if m.type == Member.ORG:
amount = settings.FEE[m.lvl]
else:
amount = settings.FEE[m.type]
invoice_details = {
'ID': invoice_id(m),
'FULLNAME': gen_fullname(m.head_of_list),
'DATE': date.today().strftime('%Y-%m-%d'),
'YEAR': year,
'AMOUNT': amount,
'CURRENCY': INV['currency'],
}
# generate pdf invoice
from StringIO import StringIO
pdf = StringIO()
pdf_invoice(pdf, m, invoice_details)
pdf.seek(0)
fn=invoice_details['ID'] + '.pdf'
# create attachement
from email.mime.application import MIMEApplication
attachment = MIMEApplication(pdf.read())
attachment.add_header("Content-Disposition", "attachment",filename=fn)
#save invoice in Fee model
try:
F = Fee.objects.get(member=m,year=year)
F.paid = False
F.paid_date = None
F.invoice.save(fn,File(pdf),save=True)
except Fee.DoesNotExist:
F = Fee(member=m,year=year)
F.paid = False
F.paid_date = None
F.invoice.save(fn,File(pdf),save=True)
pdf.close()
# send email
from cms.functions import notify_by_email
subject = INV['subject'] % m.id
notify_by_email(m.head_of_list.email,subject,invoice_details,INV['mail_template'],attachment)
def handle_uploaded_file(f,c,subject,to,message,template):
# create random filename
fn = unicode('UPL/'+c+'/'+gen_hash(settings.REG_SALT,c,10,to)+'_'+f.name)
# save file to "campaign" folder
with open(settings.MEDIA_ROOT+fn, 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
# send file to "campaign" mailinglist
message_content = {
'MESSAGE' : message,
'LINK' : 'https://'+settings.ALLOWED_HOSTS[0]+settings.MEDIA_URL+fn,
}
notify_by_email(to, subject, message_content, template, settings.MEDIA_ROOT+fn)
def validate(r, val_hash):
title = settings.TEMPLATE_CONTENT['reg']['validate']['title']
template = settings.TEMPLATE_CONTENT['reg']['validate']['template']
done_message = settings.TEMPLATE_CONTENT['reg']['validate']['done_message']
error_message = settings.TEMPLATE_CONTENT['reg']['validate'][
'error_message']
email_template = settings.TEMPLATE_CONTENT['reg']['validate']['email'][
'template']
org_msg = settings.TEMPLATE_CONTENT['reg']['validate']['email']['org_msg']
try:
# if hash code match: it's a member to be validated
R = Registration.objects.get(hash_code=val_hash)
if R.validated == R.OK:
return render(r, template, {
'title': title,
'error_message': message,
})
R.date_of_validation = timezone.now()
R.validated = R.OK
R.save()
M = R.member
M.status = Member.ACT
M.save()
message = done_message.format(name=gen_member_fullname(M),
member_id=M.pk)
#notify by email
message_content = {
'FULLNAME': gen_member_fullname(M),
'MEMBER_ID': M.pk,
'MEMBER_TYPE': Member.MEMBER_TYPES[int(M.type)][1],
'USERNAME': M.head_of_list.username,
'CMS_URL': 'https://' + settings.ALLOWED_HOSTS[0] + '/',
}
if M.type == Member.ORG:
message_content['ORGANISATION'] = org_msg.format(
orga=M.organisation)
#send email
ok = notify_by_email('board', M.head_of_list.email, title,
message_content, email_template)
return render(r, template, {
'title': title,
'message': message,
})
except:
# else: error
return render(r, template, {
'title': title,
'error_message': error_message,
})
def submit_idea(r):
r.breadcrumbs( (
('ideabox','/ideabox/'),
) )
template = settings.TEMPLATE_CONTENT['ideabox']['template']
title = settings.TEMPLATE_CONTENT['ideabox']['title']
desc = settings.TEMPLATE_CONTENT['ideabox']['desc'].format(first_name=r.user.first_name,last_name=r.user.last_name,username=r.user.username)
submit = settings.TEMPLATE_CONTENT['ideabox']['submit']
subject = settings.TEMPLATE_CONTENT['ideabox']['email']['subject']
to = settings.EMAILS['email']['board']
done_template = settings.TEMPLATE_CONTENT['ideabox']['done']['template']
done_title = settings.TEMPLATE_CONTENT['ideabox']['done']['title']
if r.POST:
idf = IdeaForm(r.POST, r.FILES)
if idf.is_valid():
idea = idf.cleaned_data['content']
attach = idf.cleaned_data['file']
# build mail
message = gen_ideabox_message(r.user,idea)
message_content = {
'FULLNAME' : 'BOARD',
'MESSAGE' : message,
}
# send idea to board
ok=notify_by_email(to,subject,message_content,False,attach)
if not ok:
return render(r, error_template, {
'mode' : 'Error in email confirmation',
'message' : settings.TEMPLATE_CONTENT['error']['email'],
})
#all fine -> show thank you message
return render(r,done_template, {
'title' : done_title,
})
else: #from not valid -> error
return render(r,done_template, {
'title' : title,
'error_message' : settings.TEMPLATE_CONTENT['error']['gen'] + ' ' + gen_form_errors(idf),
})
else:
#no POST data yet -> show form
form = IdeaForm()
return render(r,template, {
'title' : title,
'desc' : desc,
'submit': submit,
'form' : form,
})
def password(r):
if r.POST:
pwd = PasswordChangeForm(r.user,r.POST)
if pwd.is_valid():
pwd.save()
message_content = {
'FULLNAME': r.user.first_name + ' ' + unicode.upper(r.user.last_name),
'LOGIN': r.user.username,
}
subject=settings.MAIL_CONFIRMATION['password']['subject'] % r.user.username
notify_by_email(r.user.email, subject, message_content, settings.MAIL_CONFIRMATION['password']['template'])
return render(r,'done.html', {'mode': 'changing your password', 'message': render_to_string(msettings.MAIL_CONFIRMATION['password']['template'], message_content)})
else:
return render(r,'pwd.html', {'pwd_form': PasswordChangeForm(r.user), 'login': r.user.username, 'error_message': settings.TEMPLATE_CONTENT['error']['pwd']})
else:
#no POST data yet -> show user creation form
return render(r,'pwd.html', {'pwd_form': PasswordChangeForm(r.user), 'login': r.user.username })
def send_invitation(event, m, invitation):
e_template = settings.TEMPLATE_CONTENT['events']['send']['done']['email'][
'template']
#invitation email with registration link
subject = settings.TEMPLATE_CONTENT['events']['send']['done']['email'][
'subject'] % {
'title': str(event.title)
}
message_content = {
'FULLNAME': gen_member_fullname(m),
'MESSAGE': str(invitation.message),
}
#send email
try:
return notify_by_email(
None, m.email, subject, message_content, False,
settings.MEDIA_ROOT + str(invitation.attachement))
except:
return notify_by_email(None, m.email, subject, message_content)
def generate_credit_note(m):
from members.models import Member
CRED = settings.ACCOUNTING['credit']
if m.type == Member.ORG:
amount = settings.FEE[m.lvl]
else:
amount = settings.FEE[m.type]
credit_details = {
'ID': credit_id(m),
'FULLNAME': gen_fullname(m.head_of_list),
'DATE': date.today().strftime('%Y-%m-%d'),
'AMOUNT': amount,
'CURRENCY': CRED['currency'],
}
# generate pdf credit note
from StringIO import StringIO
pdf = StringIO()
pdf_credit(pdf, m, credit_details)
pdf.seek(0)
fn=credit_details['ID'] + '.pdf'
# create attachement
from email.mime.application import MIMEApplication
attachment = MIMEApplication(pdf.read())
attachment.add_header("Content-Disposition", "attachment",filename=fn)
pdf.close()
# send email
from cms.functions import notify_by_email
subject = CRED['subject'] % m.id
notify_by_email(m.head_of_list.email,subject,credit_details,CRED['mail_template'],attachment)
def attendance(r, meeting_num, attendance_hash):
meeting = Meeting.objects.get(num=meeting_num)
title = settings.TEMPLATE_CONTENT['meetings']['attendance']['title'] % {
'meeting': meeting.title,
}
message = ''
notify = False
for m in get_active_members():
if gen_hash(meeting, m.email) == attendance_hash:
# it's a YES
meeting.attendance.add(m)
message = settings.TEMPLATE_CONTENT['meetings']['attendance'][
'yes'] % {
'name': gen_fullname(m),
}
notify = True
if gen_hash(meeting, m.email, False) == attendance_hash:
# it's a NO
meeting.excused.add(m)
message = settings.TEMPLATE_CONTENT['meetings']['attendance'][
'no'] % {
'name': gen_fullname(m),
}
notify = True
if notify:
#notify by email
message_content = {
'MESSAGE': message,
}
#send email
ok = notify_by_email(False, m.email, title, message_content)
meeting.save()
return render(
r, settings.TEMPLATE_CONTENT['meetings']['attendance']['template'], {
'title': title,
'message': message,
})
def report(r, meeting_num):
Mt = Meeting.objects.get(num=meeting_num)
if r.POST:
e_template = settings.TEMPLATE_CONTENT['meetings']['report']['done']['email']['template']
mrf = MeetingReportForm(r.POST, r.FILES)
if mrf.is_valid():
Mt.report = mrf.cleaned_data['report']
Mt.save()
send = mrf.cleaned_data['send']
if send:
email_error = { 'ok': True, 'who': [], }
for m in get_active_members():
#notifiation per email for new report
subject = settings.TEMPLATE_CONTENT['meetings']['report']['done']['email']['subject'] % { 'title': str(Mt.title) }
message_content = {
'FULLNAME' : gen_member_fullname(m),
'MESSAGE' : gen_report_message(e_template,Mt,m),
}
attachement = settings.MEDIA_ROOT + str(Mt.report)
#send email
ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,attachement)
if not ok:
email_error['ok']=False
email_error['who'].append(m.email)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['report']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['report']['done']['title'],
'error_message': settings.TEMPLATE_CONTENT['error']['email'] + ' ; '.join([e for e in email_error['who']]),
})
else:
# done -> with sending
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['report']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['report']['done']['title_send'],
'message': settings.TEMPLATE_CONTENT['meetings']['report']['done']['message_send'] + ' ; '.join([gen_member_fullname(m) for m in get_active_members()]),
})
else:
# done -> no sending
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['report']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['report']['done']['title'],
'message': settings.TEMPLATE_CONTENT['meetings']['report']['done']['message'],
})
# form not valid -> error
else:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['report']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['report']['done']['title'],
'error_message': settings.TEMPLATE_CONTENT['error']['gen'] + ' ; '.join([e for e in mrf.errors]),
})
# no post yet -> empty form
else:
form = MeetingReportForm(initial={ 'num': Mt.num, 'title': Mt.title, 'when': visualiseDateTime(Mt.when), })
title = settings.TEMPLATE_CONTENT['meetings']['report']['title'].format(str(Mt.num))
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['report']['template'], {
'title': title,
'desc': settings.TEMPLATE_CONTENT['meetings']['report']['desc'],
'submit': settings.TEMPLATE_CONTENT['meetings']['report']['submit'],
'form': form,
})
def invite(r, meeting_num, member_id):
Mt = M = None
if meeting_num:
Mt = Meeting.objects.get(pk=meeting_num)
if member_id:
M = Member.objects.get(pk=member_id)
else:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['invite']['done']['title'],
'error_message': settings.TEMPLATE_CONTENT['error']['gen'],
})
if r.POST:
e_template = settings.TEMPLATE_CONTENT['meetings']['invite']['done']['email']['template']
ifs = InviteeFormSet(r.POST)
if ifs.is_valid():
invitees = []
I = Invitation.objects.get(meeting=Mt)
invitation_message = gen_invitee_message(e_template,Mt,M)
try: invitation_message += I.additional_message
except: pass
email_error = { 'ok': True, 'who': [], }
for i in ifs:
Iv = i.save(commit=False)
Iv.meeting = Mt
Iv.member = M
if Iv.email:
Iv.save()
#invitation email for invitee(s)
subject = settings.TEMPLATE_CONTENT['meetings']['invite']['done']['email']['subject'] % { 'title': str(Mt.title) }
message_content = {
'FULLNAME' : gen_member_fullname(Iv),
'MESSAGE' : invitation_message,
}
#send email
#no need to add attachement for invitees
# try:
# ok=notify_by_email(settings.EMAILS['sender']['default'],Iv.email,subject,message_content,False,settings.MEDIA_ROOT + str(I.attachement))
# except:
ok=notify_by_email(settings.EMAILS['sender']['default'],Iv.email,subject,message_content)
if not ok:
email_error['ok']=False
email_error['who'].append(Iv.email)
# all fine -> save Invitee
invitees.append(Iv)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['invite']['done']['title'],
'error_message': settings.TEMPLATE_CONTENT['error']['email'] + ' ; '.join([e for e in email_error['who']]),
})
# all fine -> done
I.sent = timezone.now()
I.save()
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['invite']['done']['title'],
'message': settings.TEMPLATE_CONTENT['meetings']['invite']['done']['message'] % { 'email': invitation_message, 'attachement': I.attachement, 'list': ' ; '.join([gen_member_fullname(i) for i in invitees]), },
})
# form not valid -> error
else:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']['template'], {
'error_message': settings.TEMPLATE_CONTENT['error']['gen'] + ' ; '.join([str(e) for e in ifs.errors]),
})
# no post yet -> empty form
else:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['invite']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['invite']['title'] + str(Mt),
'desc': settings.TEMPLATE_CONTENT['meetings']['invite']['desc'],
'submit': settings.TEMPLATE_CONTENT['meetings']['invite']['submit'],
'form': InviteeFormSet(),
})
def send(r, meeting_num):
e_template = settings.TEMPLATE_CONTENT['meetings']['send']['done']['email']['template']
Mt = Meeting.objects.get(num=meeting_num)
I = None
try:
I = Invitation.objects.get(meeting=Mt)
except Invitation.DoesNotExist:
I = Invitation(meeting=Mt)
I.save()
title = settings.TEMPLATE_CONTENT['meetings']['send']['done']['title'] % str(Mt.title)
email_error = { 'ok': True, 'who': [], }
missing_members = get_meeting_missing_active_members(Mt)
if not missing_members:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'], {
'title': title,
'message': settings.TEMPLATE_CONTENT['meetings']['send']['done']['none_missing'],
})
for m in missing_members:
#invitation email with "YES/NO button"
subject = settings.TEMPLATE_CONTENT['meetings']['send']['done']['email']['subject'] % { 'title': str(Mt.title) }
invitation_message = gen_invitation_message(e_template,Mt,Event.MEET,m)
message_content = {
'FULLNAME' : gen_member_fullname(m),
'MESSAGE' : invitation_message + str(I.message),
}
#generate ical invite TODO: fix since py3 migration
#invite = genIcal(Mt)
#send email
try: #with attachement
# ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,[invite,settings.MEDIA_ROOT + str(I.attachement)])
ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,settings.MEDIA_ROOT + str(I.attachement))
except: #no attachement
# ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,invite)
ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content)
if not ok:
email_error['ok']=False
email_error['who'].append(m.email)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'], {
'title': title,
'error_message': settings.TEMPLATE_CONTENT['error']['email'] + ' ; '.join([e for e in email_error['who']]),
})
# all fine -> done
else:
I.sent = timezone.now()
I.save()
return TemplateResponse(r, settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'], {
'title': title,
'message': settings.TEMPLATE_CONTENT['meetings']['send']['done']['message'] + ' ; '.join([gen_member_fullname(m) for m in missing_members]),
})
def renew(r):
r.breadcrumbs( (
('home','/'),
('members','/members/'),
('annual renewal','/members/renew/'),
) )
year = date.today().strftime('%Y')
template = settings.TEMPLATE_CONTENT['members']['renew']['template']
title = settings.TEMPLATE_CONTENT['members']['renew']['title'].format(year=year)
email_template = settings.TEMPLATE_CONTENT['members']['renew']['email']['template']
email_title = settings.TEMPLATE_CONTENT['members']['renew']['email']['title'].format(year=year)
m_list = '<ul>'
#loop throu all active members and send membership renewal request
for m in get_active_members():
try:
f = Fee.objects.get(member=m,year=year)
except:
# if member didn't get an invoice yet for this year
#TODO:
# renewal link only for students to renew student_proof
# for all others send invoice directly, cf members.profile.renew()
#
salt2=float(year)
renew_hash_code = gen_hash(settings.RENEW_SALT,unicode(m.head_of_list.email)+unicode(m.address).encode('ascii', 'ignore'),15,salt2)
# build request mail
message_content = {
'FULLNAME' : gen_member_fullname(m),
'YEAR' : year,
'LINK' : gen_renewal_link(renew_hash_code),
}
debug('members.renew','renewing member: '+unicode(m))
# send confirmation
ok=notify_by_email(m.head_of_list.email,email_title,message_content,email_template,copy=True)
if not ok:
return render(r, template, {
'mode': 'Error in email request',
'message': settings.TEMPLATE_CONTENT['error']['email'],
})
try:
renew = Renew.objects.get(member=m,year=year)
renew.ok = False
renew.save()
except Renew.DoesNotExist:
renew = Renew(member=m,year=year,renew_code=renew_hash_code)
renew.save()
m_list += '<li>'+gen_member_fullname(m)+'</li>'
m_list += '</ul>'
# all fine
return render(r, template, {
'title' : title,
'message' : m_list,
})
def done(self, fl, form_dict, **kwargs):
self.request.breadcrumbs((('registration', '/reg/'), ))
done_title = settings.TEMPLATE_CONTENT['reg']['register']['done'][
'title']
done_template = settings.TEMPLATE_CONTENT['reg']['register']['done'][
'template']
error_template = settings.TEMPLATE_CONTENT['reg']['register']['done'][
'error_template']
email_template = settings.TEMPLATE_CONTENT['reg']['register']['done'][
'email_template']
m_id = gen_member_id()
M = O = A = U = D = Gs = None
t_f = form_dict['type']
ty = int(t_f.cleaned_data['member_type'])
a_f = form_dict['address']
h_f = form_dict['head']
if a_f.is_valid() and h_f.is_valid():
A = a_f.save()
U = h_f.save()
#organisation
if ty == Member.ORG:
o = a_f.cleaned_data['organisation']
O = Organisation(name=o, address=A)
# add head-of-list permissions
is_hol_d = Permission.objects.get(codename='MEMBER')
U.user_permissions.add(is_hol_d)
# delegate
delegate = h_f.cleaned_data['delegate']
if delegate:
d_f = form_dict['delegate']
if d_f.is_valid():
D = d_f.save()
#student
if ty == Member.STD:
sp_f = form_dict['student_proof']
if sp_f.is_valid():
M = sp_f.save(commit=False)
M.pk = m_id
M.type = ty
if M == None: M = Member(pk=m_id, type=ty)
# add address, orga and head_of_list to Member model
if ty == Member.ORG: M.organisation = O
M.address = A
M.head_of_list = U
M.save()
if D != None: M.users.add(D)
g_f = form_dict['group']
if g_f.is_valid():
Gs = g_f.cleaned_data['groups']
add_to_groups(U, Gs)
reg_hash_code = gen_hash(settings.REG_SALT, M.head_of_list.email,
15, M.address)
# create registration entry for out-of-bound validation
R = Registration(member=M,
hash_code=reg_hash_code,
date_of_registration=timezone.now())
R.save()
# build confirmation mail
message_content = {
'FULLNAME': gen_member_fullname(M),
'MEMBER_TYPE': Member.MEMBER_TYPES[int(M.type)][1],
'LINK': gen_confirmation_link(reg_hash_code),
}
# send confirmation
ok = notify_by_email(False, M.head_of_list.email, done_title,
message_content, email_template)
if not ok:
return render(
self.request, error_template, {
'mode': 'Error in email confirmation',
'message': settings.TEMPLATE_CONTENT['error']['email'],
})
# generate invoice (this will send the invoice email implicitly)
# generate_invoice(M)
head = False
if int(M.type) == int(Member.ORG): head = True
# done, redirect to thank you page
return render(
self.request, done_template, {
'title': done_title,
'name': gen_member_fullname(M),
'type': Member.MEMBER_TYPES[int(M.type)][1],
'head': head,
})
def add(r):
r.breadcrumbs((
('home', '/'),
('meetings', '/meetings/'),
('add a meeting', '/meetings/add/'),
))
if r.POST:
e_template = settings.TEMPLATE_CONTENT['meetings']['add']['done'][
'email']['template']
mf = MeetingForm(r.POST)
if mf.is_valid():
Mt = mf.save(commit=False)
Mt.save()
email_error = {
'ok': True,
'who': (),
}
for m in get_active_members():
#invitation email with "YES/NO button"
# subject = settings.TEMPLATE_CONTENT['meetings']['add']['done']['email']['subject'].format(title=unicode(Mt.title)))
subject = settings.TEMPLATE_CONTENT['meetings']['add']['done'][
'email']['subject'] % {
'title': unicode(Mt.title)
}
invitation_message = gen_invitation_message(e_template, Mt, m)
message_content = {
'FULLNAME':
gen_fullname(m),
'MESSAGE':
invitation_message + mf.cleaned_data['additional_message'],
}
#send email
ok = notify_by_email(r.user.email, m.email, subject,
message_content)
if not ok:
email_error['ok'] = False
email_error['who'].add(m.email)
# error in email -> show error messages
if not email_error['ok']:
return render(
r, settings.TEMPLATE_CONTENT['meetings']['add']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['add']['done']
['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['email'] +
' ; '.join([e for e in email_error['who']]),
})
# all fine -> done
else:
return render(
r, settings.TEMPLATE_CONTENT['meetings']['add']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['add']['done']
['title'],
'message':
settings.TEMPLATE_CONTENT['meetings']['add']['done']
['message'] + ' ; '.join(
[gen_fullname(m) for m in get_active_members()]),
})
# form not valid -> error
else:
return render(
r, settings.TEMPLATE_CONTENT['meetings']['add']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['add']['done']
['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['gen'] +
' ; '.join([e for e in mf.errors]),
})
# no post yet -> empty form
else:
form = MeetingForm()
try:
latest = Meeting.objects.values().latest('num')
next_num = latest['num'] + 1
form = MeetingForm(initial={
'title': str(next_num) + '. réunion statutaire',
'num': next_num,
})
except Meeting.DoesNotExist:
pass
return render(
r, settings.TEMPLATE_CONTENT['meetings']['add']['template'], {
'title': settings.TEMPLATE_CONTENT['meetings']['add']['title'],
'desc': settings.TEMPLATE_CONTENT['meetings']['add']['desc'],
'submit':
settings.TEMPLATE_CONTENT['meetings']['add']['submit'],
'form': form,
})
def attendance(r, event_type, event_id, attendance_hash):
E = M = title = deadline = e_yes = e_no = message = member = actions = None
if event_type == 'meetings':
M = Meeting.objects.get(num=event_id)
deadline = M.deadline
title = settings.TEMPLATE_CONTENT['attendance']['meeting']['title'] % {
'meeting': M.title,
}
e_yes = settings.TEMPLATE_CONTENT['attendance']['meeting']['email'][
'yes'] % {
'meeting': M.title,
}
e_no = settings.TEMPLATE_CONTENT['attendance']['meeting']['email'][
'no'] % {
'meeting': M.title,
}
if event_type == 'events':
E = Event.objects.get(pk=event_id)
deadline = E.deadline
title = settings.TEMPLATE_CONTENT['attendance']['event']['title'] % {
'event': E.title,
}
e_yes = settings.TEMPLATE_CONTENT['attendance']['event']['email'][
'yes'] % {
'event': E.title,
}
e_no = settings.TEMPLATE_CONTENT['attendance']['event']['email'][
'no'] % {
'event': E.title,
}
if timezone.now() >= deadline:
message = settings.TEMPLATE_CONTENT['attendance']['too_late']
else:
for m in get_active_members():
notify = False
e_message = None
A = None
if event_type == 'meetings':
try:
A = Meeting_Attendance.objects.get(meeting=M, member=m)
except:
A = Meeting_Attendance(meeting=M, member=m)
mTm = MtoM.objects.get(meeting=M, member=m)
if attendance_hash == mTm.yes_hash:
# it's a YES
A.present = True
A.timestamp = datetime.now()
A.save()
notify = True
member = m
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % {
'name': gen_member_fullname(m),
}
#add meeting information to the confirmation message
message += settings.TEMPLATE_CONTENT['attendance'][
'details'] % {
'when': M.when,
'time': M.time,
'location': M.location,
'address': M.location.address,
}
e_message = e_yes
if M.type == Meeting.C:
actions = settings.TEMPLATE_CONTENT['attendance'][
'actions']
#set meeting:num and member_id for invitee link
if actions:
for a in actions:
a['url'] = a['url'].format(
str(M.num), str(member.id))
if attendance_hash == mTm.no_hash:
# it's a NO
A.present = False
A.timestamp = datetime.now()
A.save()
notify = True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % {
'name': gen_member_fullname(m),
}
e_message = e_no
elif event_type == 'events':
try:
A = Event_Attendance.objects.get(event=E, member=m)
except:
A = Event_Attendance(event=E, member=m)
eTm = EtoM.objects.get(event=E, member=m)
if attendance_hash == eTm.yes_hash:
# it's a YES
A.present = True
A.timestamp = datetime.now()
A.save()
notify = True
member = m
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % {
'name': gen_member_fullname(m),
}
#add meeting information to the confirmation message
message += settings.TEMPLATE_CONTENT['attendance'][
'details'] % {
'when': E.when,
'time': E.time,
'location': E.location,
'address': E.location.address,
}
actions = settings.TEMPLATE_CONTENT['attendance'][
'actions']
e_message = e_yes
if attendance_hash == eTm.no_hash:
# it's a NO
A.present = False
A.timestamp = datetime.now()
A.save()
notify = True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % {
'name': gen_member_fullname(m),
}
e_message = e_no
if notify:
#notify by email
message_content = {
'FULLNAME': gen_member_fullname(m),
'MESSAGE': e_message,
}
#send email
ok = notify_by_email(False, m.email, title, message_content)
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['attendance']['template'], {
'title': title,
'actions': actions,
'message': message,
})
if event_type == 'events':
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['attendance']['template'], {
'title': title,
'message': message,
})
def attendance(r, event_type, event_id, attendance_hash):
E = M = title = deadline = e_yes = e_no = message = member = actions = None
if event_type == 'meetings':
M = Meeting.objects.get(num=event_id)
deadline = M.deadline
title = settings.TEMPLATE_CONTENT['attendance']['meeting']['title'] % { 'meeting': M.title, }
e_yes = settings.TEMPLATE_CONTENT['attendance']['meeting']['email']['yes'] % { 'meeting': M.title, }
e_no = settings.TEMPLATE_CONTENT['attendance']['meeting']['email']['no'] % { 'meeting': M.title, }
if event_type == 'events':
E = Event.objects.get(pk=event_id)
deadline = E.deadline
title = settings.TEMPLATE_CONTENT['attendance']['event']['title'] % { 'event': E.title, }
e_yes = settings.TEMPLATE_CONTENT['attendance']['event']['email']['yes'] % { 'event': E.title, }
e_no = settings.TEMPLATE_CONTENT['attendance']['event']['email']['no'] % { 'event': E.title, }
if timezone.now() >= deadline:
message = settings.TEMPLATE_CONTENT['attendance']['too_late']
else:
for m in get_active_members():
notify = False
e_message = None
A = None
if event_type == 'meetings':
try:
A = Meeting_Attendance.objects.get(meeting=M,member=m)
except:
A = Meeting_Attendance(meeting=M,member=m)
mTm = MtoM.objects.get(meeting=M,member=m)
if attendance_hash == mTm.yes_hash:
# it's a YES
A.present = True
A.timestamp = datetime.now()
A.save()
notify=True
member=m
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % { 'name': gen_member_fullname(m), }
#add meeting information to the confirmation message
message += settings.TEMPLATE_CONTENT['attendance']['details'] % { 'when': M.when, 'time': M.time, 'location': M.location, 'address': M.location.address, }
e_message = e_yes
if M.type == Meeting.C:
actions = settings.TEMPLATE_CONTENT['attendance']['actions']
#set meeting:num and member_id for invitee link
if actions:
for a in actions:
a['url'] = a['url'].format(str(M.num),str(member.id))
if attendance_hash == mTm.no_hash:
# it's a NO
A.present = False
A.timestamp = datetime.now()
A.save()
notify=True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % { 'name': gen_member_fullname(m), }
e_message = e_no
elif event_type == 'events':
try:
A = Event_Attendance.objects.get(event=E,member=m)
except:
A = Event_Attendance(event=E,member=m)
eTm = EtoM.objects.get(event=E,member=m)
if attendance_hash == eTm.yes_hash:
# it's a YES
A.present = True
A.timestamp = datetime.now()
A.save()
notify=True
member=m
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % { 'name': gen_member_fullname(m), }
#add meeting information to the confirmation message
message += settings.TEMPLATE_CONTENT['attendance']['details'] % { 'when': E.when, 'time': E.time, 'location': E.location, 'address': E.location.address, }
actions = settings.TEMPLATE_CONTENT['attendance']['actions']
e_message = e_yes
if attendance_hash == eTm.no_hash:
# it's a NO
A.present = False
A.timestamp = datetime.now()
A.save()
notify=True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % { 'name': gen_member_fullname(m), }
e_message = e_no
if notify:
#notify by email
message_content = {
'FULLNAME' : gen_member_fullname(m),
'MESSAGE' : e_message,
}
#send email
ok=notify_by_email(False,m.email,title,message_content)
return TemplateResponse(r, settings.TEMPLATE_CONTENT['attendance']['template'], {
'title': title,
'actions' : actions,
'message': message,
})
if event_type == 'events':
return TemplateResponse(r, settings.TEMPLATE_CONTENT['attendance']['template'], {
'title': title,
'message': message,
})
def send(r, meeting_num):
e_template = settings.TEMPLATE_CONTENT['meetings']['send']['done'][
'email']['template']
Mt = Meeting.objects.get(num=meeting_num)
I = None
try:
I = Invitation.objects.get(meeting=Mt)
except Invitation.DoesNotExist:
I = Invitation(meeting=Mt)
I.save()
title = settings.TEMPLATE_CONTENT['meetings']['send']['done'][
'title'] % str(Mt.title)
email_error = {
'ok': True,
'who': [],
}
missing_members = get_meeting_missing_active_members(Mt)
if not missing_members:
return TemplateResponse(
r,
settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'],
{
'title':
title,
'message':
settings.TEMPLATE_CONTENT['meetings']['send']['done']
['none_missing'],
})
for m in missing_members:
#invitation email with "YES/NO button"
subject = settings.TEMPLATE_CONTENT['meetings']['send']['done'][
'email']['subject'] % {
'title': str(Mt.title)
}
invitation_message = gen_invitation_message(e_template, Mt, Event.MEET,
m)
message_content = {
'FULLNAME': gen_member_fullname(m),
'MESSAGE': invitation_message + str(I.message),
}
#generate ical invite TODO: fix since py3 migration
#invite = genIcal(Mt)
#send email
try: #with attachement
# ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,[invite,settings.MEDIA_ROOT + str(I.attachement)])
ok = notify_by_email(settings.EMAILS['sender']['default'], m.email,
subject, message_content, False,
settings.MEDIA_ROOT + str(I.attachement))
except: #no attachement
# ok=notify_by_email(settings.EMAILS['sender']['default'],m.email,subject,message_content,False,invite)
ok = notify_by_email(settings.EMAILS['sender']['default'], m.email,
subject, message_content)
if not ok:
email_error['ok'] = False
email_error['who'].append(m.email)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(
r,
settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'],
{
'title':
title,
'error_message':
settings.TEMPLATE_CONTENT['error']['email'] +
' ; '.join([e for e in email_error['who']]),
})
# all fine -> done
else:
I.sent = timezone.now()
I.save()
return TemplateResponse(
r,
settings.TEMPLATE_CONTENT['meetings']['send']['done']['template'],
{
'title':
title,
'message':
settings.TEMPLATE_CONTENT['meetings']['send']['done']
['message'] +
' ; '.join([gen_member_fullname(m) for m in missing_members]),
})
def invite(r, meeting_num, member_id):
Mt = M = None
if meeting_num:
Mt = Meeting.objects.get(pk=meeting_num)
if member_id:
M = Member.objects.get(pk=member_id)
else:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['gen'],
})
if r.POST:
e_template = settings.TEMPLATE_CONTENT['meetings']['invite']['done'][
'email']['template']
ifs = InviteeFormSet(r.POST)
if ifs.is_valid():
invitees = []
I = Invitation.objects.get(meeting=Mt)
invitation_message = gen_invitee_message(e_template, Mt, M)
try:
invitation_message += I.additional_message
except:
pass
email_error = {
'ok': True,
'who': [],
}
for i in ifs:
Iv = i.save(commit=False)
Iv.meeting = Mt
Iv.member = M
if Iv.email:
Iv.save()
#invitation email for invitee(s)
subject = settings.TEMPLATE_CONTENT['meetings']['invite'][
'done']['email']['subject'] % {
'title': str(Mt.title)
}
message_content = {
'FULLNAME': gen_member_fullname(Iv),
'MESSAGE': invitation_message,
}
#send email
#no need to add attachement for invitees
# try:
# ok=notify_by_email(settings.EMAILS['sender']['default'],Iv.email,subject,message_content,False,settings.MEDIA_ROOT + str(I.attachement))
# except:
ok = notify_by_email(settings.EMAILS['sender']['default'],
Iv.email, subject, message_content)
if not ok:
email_error['ok'] = False
email_error['who'].append(Iv.email)
# all fine -> save Invitee
invitees.append(Iv)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['email'] +
' ; '.join([e for e in email_error['who']]),
})
# all fine -> done
I.sent = timezone.now()
I.save()
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['title'],
'message':
settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['message'] % {
'email':
invitation_message,
'attachement':
I.attachement,
'list':
' ; '.join([gen_member_fullname(i) for i in invitees]),
},
})
# form not valid -> error
else:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['invite']['done']
['template'], {
'error_message':
settings.TEMPLATE_CONTENT['error']['gen'] +
' ; '.join([str(e) for e in ifs.errors]),
})
# no post yet -> empty form
else:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['invite']['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['invite']['title'] +
str(Mt),
'desc':
settings.TEMPLATE_CONTENT['meetings']['invite']['desc'],
'submit':
settings.TEMPLATE_CONTENT['meetings']['invite']['submit'],
'form':
InviteeFormSet(),
})
def register(r, event_hash):
E = Event.objects.get(registration=event_hash)
title = settings.TEMPLATE_CONTENT['events']['register']['title'].format(E.title)
header = settings.TEMPLATE_CONTENT['events']['register']['header']
submit = settings.TEMPLATE_CONTENT['events']['register']['submit']
e_subject = settings.TEMPLATE_CONTENT['events']['register']['email']['subject']
e_template = settings.TEMPLATE_CONTENT['events']['register']['email']['template']
done_title = settings.TEMPLATE_CONTENT['events']['register']['done']['title'].format(E.title)
if r.POST:
rf = RegistrationForm(r.POST)
if rf.is_valid():
P = rf.save(commit=False)
P.event = E
P.regcode = gen_reg_code(E,P)
try:
P.save()
except IntegrityError:
#error duplicate registration
return render(r, settings.TEMPLATE_CONTENT['events']['register']['done']['template'], {
'title' : title,
'error_message' : settings.TEMPLATE_CONTENT['error']['duplicate'],
})
e_message = gen_registration_message(e_template,E,P)
#notify by email
message_content = {
'FULLNAME' : P.first_name + ' ' + P.last_name.upper(),
'MESSAGE' : e_message,
}
#send email
ok=notify_by_email(P.email,e_subject,message_content,False)
if not ok:
#error in sending email
return render(r, settings.TEMPLATE_CONTENT['events']['register']['done']['template'], {
'title' : title,
'error_message' : settings.TEMPLATE_CONTENT['error']['email'],
})
#all fine done page
done_message = gen_event_overview(settings.TEMPLATE_CONTENT['events']['register']['done']['overview'],E,P)
return render(r, settings.TEMPLATE_CONTENT['events']['register']['done']['template'], {
'title' : done_title,
'message' : done_message,
})
#error in form
return render(r, settings.TEMPLATE_CONTENT['events']['register']['done']['template'], {
'title' : title,
'error_message' : settings.TEMPLATE_CONTENT['error']['gen'] + ' ; '.join([e for e in rf.errors]),
})
else: #empty form
form = RegistrationForm()
teaser_message = gen_event_overview(settings.TEMPLATE_CONTENT['events']['register']['teaser'],E)
return render(r, settings.TEMPLATE_CONTENT['events']['register']['template'], {
'title' : title,
'header' : header,
'form' : form,
'teaser' : teaser_message,
'submit' : submit,
})
def register(r, event_hash):
E = Event.objects.get(registration=event_hash)
title = settings.TEMPLATE_CONTENT['events']['register']['title'].format(
E.title)
header = settings.TEMPLATE_CONTENT['events']['register']['header']
submit = settings.TEMPLATE_CONTENT['events']['register']['submit']
e_subject = settings.TEMPLATE_CONTENT['events']['register']['email'][
'subject']
e_template = settings.TEMPLATE_CONTENT['events']['register']['email'][
'template']
done_title = settings.TEMPLATE_CONTENT['events']['register']['done'][
'title'].format(E.title)
if r.POST:
rf = RegistrationForm(r.POST)
if rf.is_valid():
P = rf.save(commit=False)
P.event = E
P.regcode = gen_reg_code(E, P)
try:
P.save()
except IntegrityError:
#error duplicate registration
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['events']['register']['done']
['template'], {
'title':
title,
'error_message':
settings.TEMPLATE_CONTENT['error']['duplicate'],
})
e_message = gen_registration_message(e_template, E, P)
#notify by email
message_content = {
'FULLNAME': P.first_name + ' ' + P.last_name.upper(),
'MESSAGE': e_message,
}
#send email
ok = notify_by_email(False, P.email, e_subject, message_content)
if not ok:
#error in sending email
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['events']['register']['done']
['template'], {
'title':
title,
'error_message':
settings.TEMPLATE_CONTENT['error']['email'],
})
#all fine done page
done_message = gen_event_overview(
settings.TEMPLATE_CONTENT['events']['register']['done']
['overview'], E, P)
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['events']['register']['done']
['template'], {
'title': done_title,
'message': done_message,
})
#error in form
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['events']['register']['done']
['template'], {
'title':
title,
'error_message':
settings.TEMPLATE_CONTENT['error']['gen'] +
' ; '.join([e for e in rf.errors]),
})
else: #empty form
form = RegistrationForm()
teaser_message = gen_event_overview(
settings.TEMPLATE_CONTENT['events']['register']['teaser'], E)
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['events']['register']['template'], {
'title': title,
'header': header,
'form': form,
'teaser': teaser_message,
'submit': submit,
})
def done(self, fl, form_dict, **kwargs):
self.request.breadcrumbs( (
('registration','/reg/'),
) )
done_title = settings.TEMPLATE_CONTENT['reg']['register']['done']['title']
done_template = settings.TEMPLATE_CONTENT['reg']['register']['done']['template']
error_template = settings.TEMPLATE_CONTENT['reg']['register']['done']['error_template']
email_template = settings.TEMPLATE_CONTENT['reg']['register']['done']['email_template']
m_id = gen_member_id()
M = lvl = O = A = U = D = Gs = None
Us = []
ty = None
if self.kwargs:
for item in Member.MEMBER_TYPES:
if unicode(item[1]) == unicode(self.kwargs['type']):
ty = int(item[0])
else:
t_f = form_dict['type']
ty = int(t_f.cleaned_data['member_type'])
a_f = form_dict['address']
h_f = form_dict['head']
if a_f.is_valid() and h_f.is_valid():
A = a_f.save()
U = h_f.save()
#role for hol
Ro = Role(title="Head of List",user=U)
Ro.save()
#organisation
if ty == Member.ORG:
var = a_f.cleaned_data
o = a_f.cleaned_data['organisation']
O = Organisation(name=o,address=A)
O.save()
#get nb of users
lvl = int(h_f.cleaned_data['more'])+1 #add one for head-of-list
# delegate
delegate = h_f.cleaned_data['delegate']
if delegate:
d_f = form_dict['delegate']
if d_f.is_valid():
D = d_f.save()
D.save()
#role for delegate
Ro = Role(title="Delegate",user=D)
Ro.save()
#all users for ORG type
mu_fs = form_dict['more']
if mu_fs.is_valid():
for u in mu_fs:
if u.is_valid() and u.has_changed():
if u.cleaned_data['email']:
user = u.save(commit=False)
user.username = gen_username(user.first_name,user.last_name)
user.is_active = False
user.password = make_password(gen_random_password())
user.save()
Us.append(user)
#student
if ty == Member.STD:
sp_f = form_dict['student_proof']
if sp_f.is_valid():
M = sp_f.save(commit=False)
M.pk=m_id
M.type=ty
if M == None: M = Member(pk=m_id,type=ty)
# if of type org, add organisation to Member model
if ty == Member.ORG: M.organisation = O
# add address and head_of_list to Member model
M.address=A
M.head_of_list=U
#set the level (number of users) for ORG type
if lvl: M.lvl=lvl
# add delegate if exists
if D != None: M.delegate=D
# add member_type if in alt mode
M.type = ty
# save Member model
M.save()
# add all Users for ORG type
if Us != []: M.users=Us
reg_hash_code = gen_hash(settings.REG_SALT,M.head_of_list.email,15,M.address)
# create registration entry for out-of-bound validation
R = Registration(member=M,hash_code=reg_hash_code,date_of_registration=timezone.now())
R.save()
# build confirmation mail
message_content = {
'FULLNAME' : gen_member_fullname(M),
'MEMBER_TYPE' : Member.MEMBER_TYPES[int(M.type)][1],
'LINK' : gen_confirmation_link(reg_hash_code),
}
# send confirmation
ok=notify_by_email(M.head_of_list.email,done_title,message_content,email_template,None,settings.EMAILS['email']['secgen'])
if not ok:
return render(self.request, error_template, {
'mode': 'Error in email confirmation',
'message': settings.TEMPLATE_CONTENT['error']['email'],
})
head = False
if int(M.type) == int(Member.ORG): head = True
# done, redirect to thank you page
return render(self.request, done_template, {
'title' : done_title,
'name' : gen_member_fullname(M),
'type' : Member.MEMBER_TYPES[int(M.type)][1],
'head' : head,
})
def report(r, meeting_num):
Mt = Meeting.objects.get(num=meeting_num)
if r.POST:
e_template = settings.TEMPLATE_CONTENT['meetings']['report']['done'][
'email']['template']
mrf = MeetingReportForm(r.POST, r.FILES)
if mrf.is_valid():
Mt.report = mrf.cleaned_data['report']
Mt.save()
send = mrf.cleaned_data['send']
if send:
email_error = {
'ok': True,
'who': [],
}
for m in get_active_members():
#notifiation per email for new report
subject = settings.TEMPLATE_CONTENT['meetings']['report'][
'done']['email']['subject'] % {
'title': str(Mt.title)
}
message_content = {
'FULLNAME': gen_member_fullname(m),
'MESSAGE': gen_report_message(e_template, Mt, m),
}
attachement = settings.MEDIA_ROOT + str(Mt.report)
#send email
ok = notify_by_email(settings.EMAILS['sender']['default'],
m.email, subject, message_content,
False, attachement)
if not ok:
email_error['ok'] = False
email_error['who'].append(m.email)
# error in email -> show error messages
if not email_error['ok']:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['report']
['done']['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['report']
['done']['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['email'] +
' ; '.join([e for e in email_error['who']]),
})
else:
# done -> with sending
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['report']
['done']['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['report']
['done']['title_send'],
'message':
settings.TEMPLATE_CONTENT['meetings']['report']
['done']['message_send'] + ' ; '.join([
gen_member_fullname(m)
for m in get_active_members()
]),
})
else:
# done -> no sending
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['report']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['report']['done']
['title'],
'message':
settings.TEMPLATE_CONTENT['meetings']['report']['done']
['message'],
})
# form not valid -> error
else:
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['report']['done']
['template'], {
'title':
settings.TEMPLATE_CONTENT['meetings']['report']['done']
['title'],
'error_message':
settings.TEMPLATE_CONTENT['error']['gen'] +
' ; '.join([e for e in mrf.errors]),
})
# no post yet -> empty form
else:
form = MeetingReportForm(initial={
'num': Mt.num,
'title': Mt.title,
'when': visualiseDateTime(Mt.when),
})
title = settings.TEMPLATE_CONTENT['meetings']['report'][
'title'].format(str(Mt.num))
return TemplateResponse(
r, settings.TEMPLATE_CONTENT['meetings']['report']['template'], {
'title': title,
'desc':
settings.TEMPLATE_CONTENT['meetings']['report']['desc'],
'submit':
settings.TEMPLATE_CONTENT['meetings']['report']['submit'],
'form': form,
})
def validate(r, val_hash):
title = settings.TEMPLATE_CONTENT['reg']['validate']['title']
template = settings.TEMPLATE_CONTENT['reg']['validate']['template']
done_message = settings.TEMPLATE_CONTENT['reg']['validate']['done_message']
error_message = settings.TEMPLATE_CONTENT['reg']['validate']['error_message']
email_template = settings.TEMPLATE_CONTENT['reg']['validate']['email']['template']
org_msg = settings.TEMPLATE_CONTENT['reg']['validate']['email']['org_msg']
users_msg = settings.TEMPLATE_CONTENT['reg']['validate']['email']['users_msg']
M = R = None
debug('reg','hash == ' + val_hash)
try:
# if hash code match: it's a member to be validated
R = Registration.objects.get(hash_code=str(val_hash))
debug('reg','valid hash found')
if R.validated != R.OK: M = R.member
except Registration.DoesNotExist:
# check if validation by Board member
if r.user.is_authenticated():
debug('reg','user is logged in (!)')
if r.user.has_perm('cms.BOARD'):
debug('reg','user is board member!')
#admin validation: val_hash == member_id
R = Registration.objects.get(member=Member.objects.get(id=str(val_hash)))
if R.validated != R.OK: M = R.member
debug('reg','Member is :' + unicode(M))
if M != None:
# activate member
activate_member(M)
# save registration as OK
R.date_of_validation = timezone.now()
R.validated = R.OK
R.save()
message = done_message.format(name=gen_member_fullname(M),member_id=M.pk)
#notify by email
message_content = {
'FULLNAME' : gen_member_fullname(M),
'MEMBER_ID' : M.pk,
'MEMBER_TYPE' : Member.MEMBER_TYPES[int(M.type)][1],
'USERNAME' : M.head_of_list.username,
'CMS_URL' : 'https://'+settings.ALLOWED_HOSTS[0]+'/',
}
if M.type == Member.ORG:
message_content['ORGANISATION']=org_msg.format(orga=M.organisation)
message_content['USERS']=users_msg.format(users=gen_user_list(M))
#send email
ok=notify_by_email(M.head_of_list.email,title,message_content,email_template,None,True)
return render(r, template, {
'title' : title,
'message' : message,
})
else: #error
debug('reg','error, no valid hash found')
return render(r, template, {
'title' : title,
'error_message' : error_message,
})
def attendance_fast(r, event_type, event_id, attendance_hash):
E = M = title = deadline = e_yes = e_no = message = member = actions = None
notify = False
e_message = None
A = None
if event_type == 'meetings':
M = Meeting.objects.get(pk=event_id)
deadline = M.deadline
title = settings.TEMPLATE_CONTENT['attendance']['meeting']['title'] % { 'meeting': M.group, }
e_yes = settings.TEMPLATE_CONTENT['attendance']['meeting']['email']['yes'] % { 'meeting': M.title, }
e_no = settings.TEMPLATE_CONTENT['attendance']['meeting']['email']['no'] % { 'meeting': M.title, }
if timezone.now() >= deadline:
message = settings.TEMPLATE_CONTENT['attendance']['too_late']
else:
mTm = None
try:
mTm = MtoM.objects.get(yes_hash=attendance_hash)
# it's a YES
M = mTm.meeting
U = mTm.user
try:
A = Meeting_Attendance.objects.get(meeting=M,user=U)
except:
A = Meeting_Attendance(meeting=M,user=U)
A.present = True
A.timestamp = timezone.now()
A.save()
notify=True
member=get_member_from_username(U.username)
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % { 'name': gen_fullname(U), }
#add meeting information to the confirmation message
message += settings.TEMPLATE_CONTENT['attendance']['details'] % { 'title': M.title, 'when': M.when, 'time': visualiseDateTime(M.start) + ' - ' + visualiseDateTime(M.end), 'location': M.location, }
actions = settings.TEMPLATE_CONTENT['attendance']['actions']
e_message = e_yes
except:
try:
mTm = MtoM.objects.get(no_hash=attendance_hash)
# it's a NO
M = mTm.meeting
U = mTm.user
try:
A = Meeting_Attendance.objects.get(meeting=M,user=U)
except:
A = Meeting_Attendance(meeting=M,user=U)
A.present = False
A.timestamp = timezone.now()
A.save()
notify=True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % { 'name': gen_fullname(U), }
e_message = e_no
except:
pass
if event_type == 'events':
E = Event.objects.get(pk=event_id)
G = E.group
deadline = E.deadline
title = settings.TEMPLATE_CONTENT['attendance']['event']['title'] % { 'event': E.title, }
e_yes = settings.TEMPLATE_CONTENT['attendance']['event']['email']['yes'] % { 'event': E.title, }
e_no = settings.TEMPLATE_CONTENT['attendance']['event']['email']['no'] % { 'event': E.title, }
if timezone.now() >= deadline:
message = settings.TEMPLATE_CONTENT['attendance']['too_late']
else:
eTm = None
try:
eTm = EtoM.objects.get(yes_hash=attendance_hash)
# it's a YES
E = eTm.event
U = eTm.user
try:
A = Event_Attendance.objects.get(event=E,user=U)
except:
A = Event_Attendance(event=E,user=U)
A.present = True
A.timestamp = timezone.now()
A.save()
notify=True
member=get_member_from_username(U.username)
message = settings.TEMPLATE_CONTENT['attendance']['yes'] % { 'name': gen_fullname(U), }
actions = settings.TEMPLATE_CONTENT['attendance']['actions']
e_message = e_yes
except:
try:
eTm = EtoM.objects.get(no_hash=attendance_hash)
# it's a NO
E = eTm.event
U = eTm.user
try:
A = Event_Attendance.objects.get(event=E,user=U)
except:
A = Event_Attendance(event=E,user=U)
A.present = False
A.timestamp = timezone.now()
A.save()
notify=True
message = settings.TEMPLATE_CONTENT['attendance']['no'] % { 'name': gen_fullname(U), }
e_message = e_no
except:
pass
if notify:
#notify by email
message_content = {
'FULLNAME' : gen_fullname(U),
'MESSAGE' : e_message,
}
#send email
ok=notify_by_email(U.email,title,message_content)
#set meeting: id and member_id for invitee link
if actions:
actions[0]['url'] += str(M.pk)+'/'+str(member.id)
return render(r, settings.TEMPLATE_CONTENT['attendance']['template'], {
'title': title,
'actions' : actions,
'message': message,
})
