def handle(self, *args, **options):
from tendenci.core.base.utils import send_email_notification
from tendenci.core.site_settings.utils import get_setting
from tendenci.addons.directories.models import Directory
# Query all events that are not yet marked for checking
directories = Directory.objects.filter(renewal_notice_sent=False)
days = get_setting('module', 'directories', 'renewaldays')
days = int(days)
for directory in directories:
if datetime.now() + timedelta(days) > directory.expiration_dt:
email_recipient = directory.creator.email
print 'Sending email to %s for directory %s.' % (email_recipient, directory, )
send_email_notification(
'directory_renewal_eligible',
email_recipient,
{
'directory': directory,
}
)
directory.renewal_notice_sent = True
directory.save()
else:
print 'Directory %s not eligible for renewal right now.' % (directory, )
def handle(self, *args, **options):
from tendenci.core.base.utils import send_email_notification
from tendenci.core.site_settings.utils import get_setting
from tendenci.addons.directories.models import Directory
# Query all events that are not yet marked for checking
directories = Directory.objects.filter(renewal_notice_sent=False)
days = get_setting('module', 'directories', 'renewaldays')
days = int(days)
for directory in directories:
if datetime.now() + timedelta(days) > directory.expiration_dt:
email_recipient = directory.creator.email
print 'Sending email to %s for directory %s.' % (
email_recipient,
directory,
)
send_email_notification('directory_renewal_eligible',
email_recipient, {
'directory': directory,
})
directory.renewal_notice_sent = True
directory.save()
else:
print 'Directory %s not eligible for renewal right now.' % (
directory, )
def approve(request, id, template_name="directories/approve.html"):
can_view_directories = has_perm(request.user, 'directories.view_directory')
can_change_directories = has_perm(request.user,
'directories.change_directory')
if not all([can_view_directories, can_change_directories]):
raise Http403
directory = get_object_or_404(Directory, pk=id)
if request.method == "POST":
directory.activation_dt = datetime.now()
directory.expiration_dt = directory.activation_dt + timedelta(
days=directory.requested_duration)
directory.allow_anonymous_view = True
directory.status = True
directory.status_detail = 'active'
if not directory.creator:
directory.creator = request.user
directory.creator_username = request.user.username
if not directory.owner:
directory.owner = request.user
directory.owner_username = request.user.username
directory.save()
# send email notification to user
recipients = [directory.creator.email]
if recipients:
extra_context = {
'object': directory,
'request': request,
}
try:
send_email_notification('directory_approved_user_notice',
recipients, extra_context)
except:
pass
msg_string = 'Successfully approved %s' % directory
messages.add_message(request, messages.SUCCESS, _(msg_string))
return HttpResponseRedirect(reverse('directory',
args=[directory.slug]))
return render_to_response(template_name, {'directory': directory},
context_instance=RequestContext(request))
def approve(request, id, template_name="jobs/approve.html"):
can_view_jobs = has_perm(request.user, 'jobs.view_job')
can_change_jobs = has_perm(request.user, 'jobs.change_job')
if not all([can_view_jobs, can_change_jobs]):
raise Http403
job = get_object_or_404(Job, pk=id)
if request.method == "POST":
job.activation_dt = datetime.now()
job.allow_anonymous_view = True
job.status = True
job.status_detail = 'active'
if not job.creator:
job.creator = request.user
job.creator_username = request.user.username
if not job.owner:
job.owner = request.user
job.owner_username = request.user.username
job.save()
# send email notification to user
recipients = [job.creator.email]
if recipients:
extra_context = {
'object': job,
'request': request,
}
#try:
send_email_notification(
'job_approved_user_notice', recipients, extra_context)
#except:
# pass
messages.add_message(request, messages.SUCCESS,
'Successfully approved %s' % job)
return HttpResponseRedirect(reverse('job', args=[job.slug]))
return render_to_response(template_name, {'job': job},
context_instance=RequestContext(request))
def approve(request, id, template_name="directories/approve.html"):
can_view_directories = has_perm(request.user, 'directories.view_directory')
can_change_directories = has_perm(request.user, 'directories.change_directory')
if not all([can_view_directories, can_change_directories]):
raise Http403
directory = get_object_or_404(Directory, pk=id)
if request.method == "POST":
directory.activation_dt = datetime.now()
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
directory.allow_anonymous_view = True
directory.status = True
directory.status_detail = 'active'
if not directory.creator:
directory.creator = request.user
directory.creator_username = request.user.username
if not directory.owner:
directory.owner = request.user
directory.owner_username = request.user.username
directory.save()
# send email notification to user
recipients = [directory.creator.email]
if recipients:
extra_context = {
'object': directory,
'request': request,
}
try:
send_email_notification('directory_approved_user_notice', recipients, extra_context)
except:
pass
messages.add_message(request, messages.SUCCESS, 'Successfully approved %s' % directory)
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
return render_to_response(template_name, {'directory': directory},
context_instance=RequestContext(request))
def approve(request, id, template_name="jobs/approve.html"):
can_view_jobs = has_perm(request.user, 'jobs.view_job')
can_change_jobs = has_perm(request.user, 'jobs.change_job')
if not all([can_view_jobs, can_change_jobs]):
raise Http403
job = get_object_or_404(Job, pk=id)
if request.method == "POST":
job.activation_dt = datetime.now()
job.allow_anonymous_view = True
job.status = True
job.status_detail = 'active'
if not job.creator:
job.creator = request.user
job.creator_username = request.user.username
if not job.owner:
job.owner = request.user
job.owner_username = request.user.username
job.save()
# send email notification to user
recipients = [job.creator.email]
if recipients:
extra_context = {
'object': job,
'request': request,
}
#try:
send_email_notification(
'job_approved_user_notice', recipients, extra_context)
#except:
# pass
messages.add_message(request, messages.SUCCESS,
'Successfully approved %s' % job)
return HttpResponseRedirect(reverse('job', args=[job.slug]))
return render_to_response(template_name, {'job': job},
context_instance=RequestContext(request))
def handle(self, *args, **options):
from tendenci.core.base.utils import send_email_notification
from tendenci.core.site_settings.utils import get_setting
from tendenci.addons.events.models import Event
from tendenci.addons.events.utils import registration_has_recently_ended
site_label = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
admins = get_setting('module', 'events', 'admin_emails').split(',')
email_list = [admin.strip() for admin in admins]
# Query all events that are not yet marked for checking
events = Event.objects.filter(mark_registration_ended=False)
for event in events:
if registration_has_recently_ended(event):
# Calculate fees, number of participants, etc
money_collected = event.money_collected
money_outstanding = event.money_outstanding
all_registrants = event.registrants()
registrants_with_balance = event.registrants(with_balance=True)
print 'Sending email to admins for event %s.' % (event, )
send_email_notification(
'event_registration_end_recap', email_list, {
'SITE_GLOBAL_SITEDISPLAYNAME':
site_label,
'SITE_GLOBAL_SITEURL':
site_url,
'event':
event,
'money_collected':
money_collected,
'money_outstanding':
money_outstanding,
'registrants_count':
len(all_registrants),
'registrants_with_balance_count':
len(registrants_with_balance),
})
print 'Message sent.'
# Mark event as ended
event.mark_registration_ended = True
event.save()
def handle(self, *args, **options):
from tendenci.core.base.utils import send_email_notification
from tendenci.core.site_settings.utils import get_setting
from tendenci.addons.events.models import Event
from tendenci.addons.events.utils import registration_has_recently_ended
site_label = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
admins = get_setting('module', 'events', 'admin_emails').split(',')
email_list = [admin.strip() for admin in admins]
# Query all events that are not yet marked for checking
events = Event.objects.filter(mark_registration_ended=False)
for event in events:
if registration_has_recently_ended(event):
# Calculate fees, number of participants, etc
money_collected = event.money_collected
money_outstanding = event.money_outstanding
all_registrants = event.registrants()
registrants_with_balance = event.registrants(with_balance=True)
print 'Sending email to admins for event %s.' % (event, )
send_email_notification(
'event_registration_end_recap',
email_list,
{
'SITE_GLOBAL_SITEDISPLAYNAME': site_label,
'SITE_GLOBAL_SITEURL': site_url,
'event': event,
'money_collected': money_collected,
'money_outstanding': money_outstanding,
'registrants_count': len(all_registrants),
'registrants_with_balance_count': len(registrants_with_balance),
}
)
print 'Message sent.'
# Mark event as ended
event.mark_registration_ended = True
event.save()
def approve_join(self, request, **kwargs):
self.approved = True
self.approved_denied_dt = datetime.now()
if not request.user.is_anonymous():
self.approved_denied_user = request.user
self.status = 1
self.status_detail = 'active'
self.save()
created, username, password = self.handle_anonymous_creator(**kwargs)
# send an email to dues reps
recipients = dues_rep_emails_list(self)
recipients.append(self.creator.email)
extra_context = {
'object': self,
'request': request,
'invoice': self.invoice,
'created': created,
'username': username,
'password': password
}
send_email_notification('corp_memb_join_approved', recipients, extra_context)
def approve_join(self, request, **kwargs):
self.approved = True
self.approved_denied_dt = datetime.now()
if not request.user.is_anonymous():
self.approved_denied_user = request.user
self.status = 1
self.status_detail = 'active'
self.save()
created, username, password = self.handle_anonymous_creator(**kwargs)
# send an email to dues reps
recipients = dues_rep_emails_list(self)
recipients.append(self.creator.email)
extra_context = {
'object': self,
'request': request,
'invoice': self.invoice,
'created': created,
'username': username,
'password': password
}
send_email_notification('corp_memb_join_approved', recipients,
extra_context)
def application_details_corp_pre(request, slug, cmb_id=None, template_name="memberships/applications/details_corp_pre.html"):
try:
app = App.objects.get(slug=slug)
except App.DoesNotExist:
raise Http404
if not hasattr(app, 'corp_app'):
raise Http404
if not app.corp_app:
raise Http404
form = AppCorpPreForm(request.POST or None)
if request.user.profile.is_superuser or app.corp_app.authentication_method == 'admin':
del form.fields['secret_code']
del form.fields['email']
from utils import get_corporate_membership_choices
form.fields['corporate_membership_id'].choices = get_corporate_membership_choices()
if cmb_id:
form.fields['corporate_membership_id'].initial = cmb_id
form.auth_method = 'corporate_membership_id'
elif app.corp_app.authentication_method == 'email':
del form.fields['corporate_membership_id']
del form.fields['secret_code']
form.auth_method = 'email'
else: # secret_code
del form.fields['corporate_membership_id']
del form.fields['email']
form.auth_method = 'secret_code'
if request.method == "POST":
if form.is_valid():
# find the corporate_membership_id and redirect to membership.application_details
if form.auth_method == 'corporate_membership_id':
corporate_membership_id = form.cleaned_data['corporate_membership_id']
else:
corporate_membership_id = form.corporate_membership_id
if form.auth_method == 'email':
corp_memb = CorporateMembership.objects.get(pk=corporate_membership_id)
try:
indiv_veri = IndivMembEmailVeri8n.objects.get(corporate_membership=corp_memb,
verified_email=form.cleaned_data['email'])
if indiv_veri.verified:
is_verified = True
else:
is_verified = False
except IndivMembEmailVeri8n.DoesNotExist:
is_verified = False
indiv_veri = IndivMembEmailVeri8n()
indiv_veri.corporate_membership = corp_memb
indiv_veri.verified_email = form.cleaned_data['email']
if request.user and not request.user.is_anonymous():
indiv_veri.creator = request.user
indiv_veri.save()
# send an email to the user to verify the email address
# then redirect them to the verification conf page
# they'll need to follow the instruction in the email
# to continue to sign up.
if not is_verified:
recipients = [indiv_veri.verified_email]
extra_context = {
'object': indiv_veri,
'app': app,
'corp_memb': corp_memb,
'request': request,
}
send_email_notification('membership_corp_indiv_verify_email', recipients, extra_context)
return redirect(reverse('membership.email__to_verify_conf'))
else:
# the email address is verified
return redirect(reverse('membership.application_details_via_corp_domain',
args=[app.slug,
indiv_veri.corporate_membership.id,
indiv_veri.pk,
indiv_veri.guid]))
if form.auth_method == 'secret_code':
# secret code hash
random_string = User.objects.make_random_password(length=4, allowed_chars='abcdefghjkmnpqrstuvwxyz')
request.session['corp_hash_random_string'] = random_string
secret_code = form.cleaned_data['secret_code']
secret_hash = md5('%s%s' % (secret_code, random_string)).hexdigest()
return redirect(reverse('membership.application_details_via_corp_secret_code',
args=[app.slug,
corporate_membership_id,
secret_hash]))
return redirect(reverse('membership.application_details', args=[app.slug, corporate_membership_id]))
c = {'app': app, "form": form}
return render_to_response(template_name, c,
context_instance=RequestContext(request))
def approve_renewal(self, request, **kwargs):
"""
Approve the corporate membership renewal, and
approve the individual memberships that are
renewed with the corporate_membership
"""
from tendenci.addons.corporate_memberships.utils import dues_rep_emails_list
if self.renew_entry_id:
renew_entry = CorpMembRenewEntry.objects.get(id=self.renew_entry_id)
if renew_entry.status_detail not in ['approved', 'disapproved']:
# 1) archive corporate membership
self.archive(request.user)
user = request.user
# 2) update the corporate_membership record with the renewal info from renew_entry
self.renewal = True
self.corporate_membership_type = renew_entry.corporate_membership_type
self.payment_method = renew_entry.get_payment_method()
self.invoice = renew_entry.invoice
self.renew_dt = renew_entry.create_dt
self.approved = True
self.approved_denied_dt = datetime.now()
if user and (not user.is_anonymous()):
self.approved_denied_user = user
self.status = 1
self.status_detail = 'active'
corp_memb_type = self.corporate_membership_type
self.expiration_dt = corp_memb_type.get_expiration_dt(renewal=True,
join_dt=self.join_dt,
renew_dt=self.renew_dt)
self.save()
renew_entry.status_detail = 'approved'
renew_entry.save()
# 3) approve the individual memberships
if user and not user.is_anonymous():
user_id = user.id
username = user.username
else:
user_id = 0
username = ''
group = self.corporate_membership_type.membership_type.group
ind_memb_renew_entries = IndivMembRenewEntry.objects.filter(corp_memb_renew_entry=renew_entry)
for memb_entry in ind_memb_renew_entries:
membership = memb_entry.membership
membership.archive(user)
# update the membership record with the renewal info
membership.renewal = True
membership.renew_dt = self.renew_dt
membership.expiration_dt = self.expiration_dt
membership.corporate_membership_id = self.id
membership.membership_type = self.corporate_membership_type.membership_type
membership.status = 1
membership.status_detail = 'active'
membership.save()
# check and add member to the group if not exist
try:
gm = GroupMembership.objects.get(group=group, member=membership.user)
except GroupMembership.DoesNotExist:
gm = None
if gm:
if gm.status_detail != 'active':
gm.status_detail = 'active'
gm.save()
else:
GroupMembership.objects.create(**{
'group':group,
'member':membership.user,
'creator_id': user_id,
'creator_username': username,
'owner_id':user_id,
'owner_username':username,
'status':True,
'status_detail':'active',
})
# email dues reps that corporate membership has been approved
recipients = dues_rep_emails_list(self)
if not recipients and self.creator:
recipients = [self.creator.email]
extra_context = {
'object': self,
'request': request,
'corp_renew_entry': renew_entry,
'invoice': renew_entry.invoice,
}
send_email_notification('corp_memb_renewal_approved', recipients, extra_context)
def approve_renewal(self, request, **kwargs):
"""
Approve the corporate membership renewal, and
approve the individual memberships that are
renewed with the corporate_membership
"""
from tendenci.addons.corporate_memberships.utils import dues_rep_emails_list
if self.renew_entry_id:
renew_entry = CorpMembRenewEntry.objects.get(
id=self.renew_entry_id)
if renew_entry.status_detail not in ['approved', 'disapproved']:
# 1) archive corporate membership
self.archive(request.user)
user = request.user
# 2) update the corporate_membership record with the renewal info from renew_entry
self.renewal = True
self.corporate_membership_type = renew_entry.corporate_membership_type
self.payment_method = renew_entry.get_payment_method()
self.invoice = renew_entry.invoice
self.renew_dt = renew_entry.create_dt
self.approved = True
self.approved_denied_dt = datetime.now()
if user and (not user.is_anonymous()):
self.approved_denied_user = user
self.status = 1
self.status_detail = 'active'
corp_memb_type = self.corporate_membership_type
self.expiration_dt = corp_memb_type.get_expiration_dt(
renewal=True, join_dt=self.join_dt, renew_dt=self.renew_dt)
self.save()
renew_entry.status_detail = 'approved'
renew_entry.save()
# 3) approve the individual memberships
if user and not user.is_anonymous():
user_id = user.id
username = user.username
else:
user_id = 0
username = ''
group = self.corporate_membership_type.membership_type.group
ind_memb_renew_entries = IndivMembRenewEntry.objects.filter(
corp_memb_renew_entry=renew_entry)
for memb_entry in ind_memb_renew_entries:
membership = memb_entry.membership
membership.archive(user)
# update the membership record with the renewal info
membership.renewal = True
membership.renew_dt = self.renew_dt
membership.expiration_dt = self.expiration_dt
membership.corporate_membership_id = self.id
membership.membership_type = self.corporate_membership_type.membership_type
membership.status = 1
membership.status_detail = 'active'
membership.save()
# check and add member to the group if not exist
try:
gm = GroupMembership.objects.get(
group=group, member=membership.user)
except GroupMembership.DoesNotExist:
gm = None
if gm:
if gm.status_detail != 'active':
gm.status_detail = 'active'
gm.save()
else:
GroupMembership.objects.create(
**{
'group': group,
'member': membership.user,
'creator_id': user_id,
'creator_username': username,
'owner_id': user_id,
'owner_username': username,
'status': True,
'status_detail': 'active',
})
# email dues reps that corporate membership has been approved
recipients = dues_rep_emails_list(self)
if not recipients and self.creator:
recipients = [self.creator.email]
extra_context = {
'object': self,
'request': request,
'corp_renew_entry': renew_entry,
'invoice': renew_entry.invoice,
}
send_email_notification('corp_memb_renewal_approved',
recipients, extra_context)
def application_details_corp_pre(request, slug, cmb_id=None, template_name="memberships/applications/details_corp_pre.html"):
try:
app = App.objects.get(slug=slug)
except App.DoesNotExist:
raise Http404
if not hasattr(app, 'corp_app'):
raise Http404
if not app.corp_app:
raise Http404
form = AppCorpPreForm(request.POST or None)
if request.user.profile.is_superuser or app.corp_app.authentication_method == 'admin':
del form.fields['secret_code']
del form.fields['email']
from utils import get_corporate_membership_choices
form.fields['corporate_membership_id'].choices = get_corporate_membership_choices()
if cmb_id:
form.fields['corporate_membership_id'].initial = cmb_id
form.auth_method = 'corporate_membership_id'
elif app.corp_app.authentication_method == 'email':
del form.fields['corporate_membership_id']
del form.fields['secret_code']
form.auth_method = 'email'
else: # secret_code
del form.fields['corporate_membership_id']
del form.fields['email']
form.auth_method = 'secret_code'
if request.method == "POST":
if form.is_valid():
# find the corporate_membership_id and redirect to membership.application_details
if form.auth_method == 'corporate_membership_id':
corporate_membership_id = form.cleaned_data['corporate_membership_id']
else:
corporate_membership_id = form.corporate_membership_id
if form.auth_method == 'email':
corp_memb = CorporateMembership.objects.get(pk=corporate_membership_id)
try:
indiv_veri = IndivMembEmailVeri8n.objects.get(corporate_membership=corp_memb,
verified_email=form.cleaned_data['email'])
if indiv_veri.verified:
is_verified = True
else:
is_verified = False
except IndivMembEmailVeri8n.DoesNotExist:
is_verified = False
indiv_veri = IndivMembEmailVeri8n()
indiv_veri.corporate_membership = corp_memb
indiv_veri.verified_email = form.cleaned_data['email']
if request.user and not request.user.is_anonymous():
indiv_veri.creator = request.user
indiv_veri.save()
# send an email to the user to verify the email address
# then redirect them to the verification conf page
# they'll need to follow the instruction in the email
# to continue to sign up.
if not is_verified:
recipients = [indiv_veri.verified_email]
extra_context = {
'object': indiv_veri,
'app': app,
'corp_memb': corp_memb,
'request': request,
}
send_email_notification('membership_corp_indiv_verify_email', recipients, extra_context)
return redirect(reverse('membership.email__to_verify_conf'))
else:
# the email address is verified
return redirect(reverse('membership.application_details_via_corp_domain',
args=[app.slug,
indiv_veri.corporate_membership.id,
indiv_veri.pk,
indiv_veri.guid]))
if form.auth_method == 'secret_code':
# secret code hash
random_string = User.objects.make_random_password(length=4, allowed_chars='abcdefghjkmnpqrstuvwxyz')
request.session['corp_hash_random_string'] = random_string
secret_code = form.cleaned_data['secret_code']
secret_hash = md5('%s%s' % (secret_code, random_string)).hexdigest()
return redirect(reverse('membership.application_details_via_corp_secret_code',
args=[app.slug,
corporate_membership_id,
secret_hash]))
return redirect(reverse('membership.application_details', args=[app.slug, corporate_membership_id]))
c = {'app': app, "form": form}
return render_to_response(template_name, c,
context_instance=RequestContext(request))
