def email_admins_recap(notices, total_sent):
"""Send admins recap after the notices were processed.
"""
recap_recipient = get_admin_emails()
if recap_recipient:
template_name = "corporate_memberships/notices/email_recap.html"
try:
recap_email_content = render_to_string(
template_name,
{'notices': notices,
'total_sent': total_sent,
'site_url': site_url,
'site_display_name': site_display_name,
'site_contact_name': site_contact_name,
'site_contact_email': site_contact_email})
recap_subject = '%s Corporate Membership Notices Distributed' % (
site_display_name)
email_context.update({
'subject':recap_subject,
'content': recap_email_content,
'content_type':"html"})
notification.send_emails(recap_recipient, 'corp_memb_notice_email',
email_context)
except TemplateDoesNotExist:
pass
def delete(request, id, template_name="committees/delete.html"):
committee = get_object_or_404(Committee, pk=id)
if not has_perm(request.user, 'committees.delete_committee'):
raise Http403
if request.method == "POST":
EventLog.objects.log(instance=committee)
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % committee)
# send notification to administrators
recipients = get_notice_recipients('module', 'committees', 'committeerecipients')
if recipients:
if notification:
extra_context = {
'object': committee,
'request': request,
}
notification.send_emails(recipients, 'committee_deleted', extra_context)
committee.delete()
return HttpResponseRedirect(reverse('committees.search'))
return render_to_response(template_name, {'committee': committee},
context_instance=RequestContext(request))
def delete(request, id, template_name="resumes/delete.html"):
resume = get_object_or_404(Resume, pk=id)
if has_perm(request.user,'resumes.delete_resume'):
if request.method == "POST":
log_defaults = {
'event_id' : 433000,
'event_data': '%s (%d) deleted by %s' % (resume._meta.object_name, resume.pk, request.user),
'description': '%s deleted' % resume._meta.object_name,
'user': request.user,
'request': request,
'instance': resume,
}
EventLog.objects.log(**log_defaults)
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % resume)
# send notification to administrators
recipients = get_notice_recipients('module', 'resumes', 'resumerecipients')
if recipients:
if notification:
extra_context = {
'object': resume,
'request': request,
}
notification.send_emails(recipients,'resume_deleted', extra_context)
resume.delete()
return HttpResponseRedirect(reverse('resume.search'))
return render_to_response(template_name, {'resume': resume},
context_instance=RequestContext(request))
else:
raise Http403
def add(request, form_class=NewsForm, template_name="news/add.html"):
# check permission
if not has_perm(request.user, 'news.add_news'):
raise Http403
if request.method == "POST":
form = form_class(request.POST, user=request.user)
if form.is_valid():
news = form.save(commit=False)
# update all permissions and save the model
news = update_perms_and_save(request, form, news)
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % news)
# send notification to administrators
recipients = get_notice_recipients('module', 'news', 'newsrecipients')
if recipients:
if notification:
extra_context = {
'object': news,
'request': request,
}
notification.send_emails(recipients, 'news_added', extra_context)
return HttpResponseRedirect(reverse('news.detail', args=[news.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def add(request, form_class=ArticleForm, template_name="articles/add.html"):
if has_perm(request.user, 'articles.add_article'):
if request.method == "POST":
form = form_class(request.POST, user=request.user)
if form.is_valid():
article = form.save(commit=False)
# add all permissions and save the model
update_perms_and_save(request, form, article)
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % article)
# send notification to administrator(s) and module recipient(s)
recipients = get_notice_recipients('module', 'articles', 'articlerecipients')
if recipients and notification:
notification.send_emails(recipients, 'article_added', {
'object': article,
'request': request,
})
return HttpResponseRedirect(reverse('article', args=[article.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
else:
raise Http403
def delete(request, id, template_name="articles/delete.html"):
article = get_object_or_404(Article, pk=id)
if has_perm(request.user, 'articles.delete_article'):
if request.method == "POST":
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % article)
# send notification to administrators
recipients = get_notice_recipients('module', 'articles', 'articlerecipients')
if recipients:
if notification:
extra_context = {
'object': article,
'request': request,
}
notification.send_emails(recipients, 'article_deleted', extra_context)
article.delete()
return HttpResponseRedirect(reverse('article.search'))
return render_to_response(template_name, {'article': article},
context_instance=RequestContext(request))
else:
raise Http403
def send_welcome_email(user):
"""
Send email to user account.
Expects user account else returns false.
"""
from django.utils.http import int_to_base36
from django.contrib.auth.tokens import default_token_generator
from tendenci.core.site_settings.utils import get_setting
token_generator = default_token_generator
site_url = get_setting("site", "global", "siteurl")
site_name = get_setting("site", "global", "sitedisplayname")
# send new user account welcome email (notification)
send_emails(
[user.email],
"user_welcome",
{
"site_url": site_url,
"site_name": site_name,
"uid": int_to_base36(user.id),
"user": user,
"username": user.username,
"token": token_generator.make_token(user),
},
)
def delete(request, id, template_name="resumes/delete.html"):
resume = get_object_or_404(Resume, pk=id)
if has_perm(request.user, "resumes.delete_resume"):
if request.method == "POST":
log_defaults = {
"event_id": 433000,
"event_data": "%s (%d) deleted by %s" % (resume._meta.object_name, resume.pk, request.user),
"description": "%s deleted" % resume._meta.object_name,
"user": request.user,
"request": request,
"instance": resume,
}
EventLog.objects.log(**log_defaults)
messages.add_message(request, messages.SUCCESS, "Successfully deleted %s" % resume)
# send notification to administrators
recipients = get_notice_recipients("module", "resumes", "resumerecipients")
if recipients:
if notification:
extra_context = {"object": resume, "request": request}
notification.send_emails(recipients, "resume_deleted", extra_context)
resume.delete()
return HttpResponseRedirect(reverse("resume.search"))
return render_to_response(template_name, {"resume": resume}, context_instance=RequestContext(request))
else:
raise Http403
def auto_update_paid_object(self, request, payment):
"""
Update the object after online payment is received.
"""
from datetime import datetime
try:
from tendenci.apps.notifications import models as notification
except:
notification = None
from tendenci.core.perms.utils import get_notice_recipients
# approve it
if self.renew_entry_id:
self.approve_renewal(request)
else:
self.approve_join(request)
# send notification to administrators
recipients = get_notice_recipients('module', 'corporate_memberships', 'corporatemembershiprecipients')
if recipients:
if notification:
extra_context = {
'object': self,
'request': request,
}
notification.send_emails(recipients,'corp_memb_paid', extra_context)
def add(request, form_class=NewsForm, template_name="news/add.html"):
# check permission
if not has_perm(request.user, "news.add_news"):
raise Http403
if request.method == "POST":
form = form_class(request.POST, request.FILES, user=request.user)
if form.is_valid():
news = form.save(commit=False)
# update all permissions and save the model
news = update_perms_and_save(request, form, news)
# save photo
photo = form.cleaned_data["photo_upload"]
if photo:
news.save(photo=photo)
assign_files_perms(news, files=[news.thumbnail])
messages.add_message(request, messages.SUCCESS, "Successfully added %s" % news)
# send notification to administrators
recipients = get_notice_recipients("module", "news", "newsrecipients")
if recipients:
if notification:
extra_context = {"object": news, "request": request}
notification.send_emails(recipients, "news_added", extra_context)
return HttpResponseRedirect(reverse("news.detail", args=[news.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {"form": form}, context_instance=RequestContext(request))
def delete(request, id, template_name="news/delete.html"):
news = get_object_or_404(News, pk=id)
# check permission
if not has_perm(request.user, 'news.delete_news'):
raise Http403
if request.method == "POST":
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % news)
# send notification to administrators
recipients = get_notice_recipients('module', 'news', 'newsrecipients')
if recipients:
if notification:
extra_context = {
'object': news,
'request': request,
}
notification.send_emails(recipients, 'news_deleted', extra_context)
news.delete()
return HttpResponseRedirect(reverse('news.search'))
return render_to_response(template_name, {'news': news},
context_instance=RequestContext(request))
def save_model(self, request, object, form, change):
instance = form.save(commit=False)
instance = update_perms_and_save(request, form, instance)
if instance.meta:
meta = instance.meta
else:
meta = MetaTags()
meta.title = form.cleaned_data['meta_title']
meta.description = form.cleaned_data['meta_description']
meta.keywords = form.cleaned_data['meta_keywords']
meta.canonical_url = form.cleaned_data['meta_canonical_url']
meta.save()
instance.meta = meta
instance.save()
# notifications
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients('module', 'pages', 'pagerecipients')
notice_type = 'page_added'
if change: notice_type = 'page_edited'
if recipients:
if notification:
extra_context = {
'object': instance,
'request': request,
}
notification.send_emails(recipients, notice_type, extra_context)
return instance
def delete(request, id, template_name="studygroups/delete.html"):
study_group = get_object_or_404(StudyGroup, pk=id)
if not has_perm(request.user, 'studygroup.delete_studygroup'):
raise Http403
if request.method == "POST":
EventLog.objects.log(instance=study_group)
messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % study_group)
# send notification to administrators
recipients = get_notice_recipients('module', 'studygroups', 'studygrouprecipients')
if recipients:
if notification:
extra_context = {
'object': study_group,
'request': request,
}
notification.send_emails(recipients, 'studygroup_deleted', extra_context)
study_group.delete()
return HttpResponseRedirect(reverse('studygroups.search'))
return render_to_response(template_name, {'study_group': study_group},
context_instance=RequestContext(request))
def delete(request, id, template_name="pages/delete.html"):
page = get_object_or_404(Page, pk=id)
if not has_perm(request.user, 'pages.delete_page'):
raise Http403
if request.method == "POST":
EventLog.objects.log(instance=page)
messages.add_message(request, messages.SUCCESS,
_('Successfully deleted %(p)s' % { 'p': unicode(page)}))
# send notification to administrators
recipients = get_notice_recipients('module', 'pages', 'pagerecipients')
if recipients:
if notification:
extra_context = {
'object': page,
'request': request,
}
notification.send_emails(recipients, 'page_deleted', extra_context)
# Soft delete
page.status = False
page.status_detail = 'inactive'
page.save()
return HttpResponseRedirect(reverse('page.search'))
return render_to_response(template_name, {'page': page},
context_instance=RequestContext(request))
def delete(request, id, template_name="directories/delete.html"):
directory = get_object_or_404(Directory, pk=id)
if has_perm(request.user,'directories.delete_directory'):
if request.method == "POST":
msg_string = 'Successfully deleted %s' % directory
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrators
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_deleted', extra_context)
directory.delete()
return HttpResponseRedirect(reverse('directory.search'))
return render_to_response(template_name, {'directory': directory},
context_instance=RequestContext(request))
else:
raise Http403
def email_member(notice, membership, global_context):
user = membership.user
body = notice.email_content
context = membership.get_field_items()
context['membership'] = membership
context.update(global_context)
# corporate member corp_replace_str
if membership.corporate_membership_id:
context['corporate_membership_notice'] = corp_replace_str
if membership.expire_dt:
context.update({
'expire_dt': time.strftime(
"%d-%b-%y %I:%M %p",
membership.expire_dt.timetuple()),
})
if membership.payment_method:
payment_method_name = membership.payment_method.human_name
else:
payment_method_name = ''
context.update({
'member_number': membership.member_number,
'payment_method': payment_method_name,
'referer_url': '%s%s?next=%s' % (site_url, reverse('auth_login'), membership.referer_url),
'membership_link': '%s%s' % (site_url, membership.get_absolute_url()),
'renew_link': '%s%s' % (site_url, membership.get_absolute_url())
})
body = fieldify(body)
body = '%s <br /><br />%s' % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email_recipient = user.email
subject = notice.subject.replace('(name)',
user.get_full_name())
template = Template(subject)
subject = template.render(context)
email_context.update({
'subject':subject,
'content':body})
if notice.sender:
email_context.update({
'sender':notice.sender,
'reply_to':notice.sender})
if notice.sender_display:
email_context.update({'sender_display':notice.sender_display})
notification.send_emails([email_recipient], 'membership_notice_email',
email_context)
if verbosity > 1:
print 'To ', email_recipient, subject
def group_delete(request, id, template_name="user_groups/delete.html"):
group = get_object_or_404(Group, pk=id)
if not has_perm(request.user,'user_groups.delete_group',group): raise Http403
if request.method == "POST":
# send notification to administrators
recipients = get_notice_recipients('module', 'groups', 'grouprecipients')
if recipients:
if notification:
extra_context = {
'object': group,
'request': request,
}
notification.send_emails(recipients,'group_deleted', extra_context)
log_defaults = {
'event_id' : 163000,
'event_data': '%s (%d) deleted by %s' % (group._meta.object_name, group.pk, request.user),
'description': '%s deleted' % group._meta.object_name,
'user': request.user,
'request': request,
'instance': group,
}
EventLog.objects.log(**log_defaults)
group.delete()
return HttpResponseRedirect(reverse('group.search'))
return render_to_response(template_name, {'group':group},
context_instance=RequestContext(request))
def send_notifications(scope, scope_category, name, label, extra_context=None):
"""
a small wrapper for sending notification emails to
recipients specified in site_settings.
"""
recipients = get_notice_recipients(scope, scope_category, name)
if recipients:
send_emails(recipients, label, extra_context)
def add(request, form_class=ResumeForm, template_name="resumes/add.html"):
can_add_active = has_perm(request.user, 'resumes.add_resume')
if request.method == "POST":
form = form_class(request.POST or None, user=request.user)
if form.is_valid():
resume = form.save(commit=False)
# set it to pending if the user does not have add permission
if not can_add_active:
resume.status = 0
resume.status_detail = 'pending'
# set up the expiration time based on requested duration
now = now_localized()
resume.expiration_dt = now + timedelta(days=resume.requested_duration)
resume = update_perms_and_save(request, form, resume)
# we need to save instance first since we need the id for the file path
if request.FILES:
resume.resume_file = request.FILES['resume_file']
resume.resume_file.file.seek(0)
resume.save()
log_defaults = {
'event_id' : 351000,
'event_data': '%s (%d) added by %s' % (resume._meta.object_name, resume.pk, request.user),
'description': '%s added' % resume._meta.object_name,
'user': request.user,
'request': request,
'instance': resume,
}
EventLog.objects.log(**log_defaults)
if request.user.is_authenticated():
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % resume)
# send notification to administrators
recipients = get_notice_recipients('module', 'resumes', 'resumerecipients')
if recipients:
if notification:
extra_context = {
'object': resume,
'request': request,
}
notification.send_emails(recipients,'resume_added', extra_context)
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('resume.thank_you'))
else:
return HttpResponseRedirect(reverse('resume', args=[resume.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form':form},
context_instance=RequestContext(request))
def group_add_edit(request, group_slug=None,
form_class=GroupForm,
template_name="user_groups/add_edit.html"):
add, edit = False, False
if group_slug:
group = get_object_or_404(Group, slug=group_slug)
if not has_perm(request.user,'user_groups.change_group',group):
raise Http403
title = _("Edit Group")
edit = True
else:
group = None
if not has_perm(request.user,'user_groups.add_group'):raise Http403
title = _("Add Group")
add = True
if request.method == 'POST':
if edit:
form = form_class(request.POST, instance=group, user=request.user)
else:
form = form_class(request.POST, user=request.user)
if form.is_valid():
group = form.save(commit=False)
if not group.id:
group.creator = request.user
group.creator_username = request.user.username
# set up user permission
group.allow_user_view, group.allow_user_edit = form.cleaned_data['user_perms']
group.owner = request.user
group.owner_username = request.user.username
group = form.save()
if add:
# send notification to administrators
recipients = get_notice_recipients('module', 'groups', 'grouprecipients')
if recipients:
if notification:
extra_context = {
'object': group,
'request': request,
}
notification.send_emails(recipients,'group_added', extra_context)
EventLog.objects.log(instance=group)
return HttpResponseRedirect(group.get_absolute_url())
else:
if edit:
form = form_class(instance=group, user=request.user)
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form':form, 'titie':title, 'group':group}, context_instance=RequestContext(request))
def send_email_notification(notice_name, recipients, extra_context):
"""
Send email notice specified by the notice_name to the recipients.
recipients - a list of emails
"""
try:
from tendenci.apps.notifications import models as notification
except:
notification = None
if notification and recipients:
notification.send_emails(recipients, notice_name, extra_context)
def add(request, form_class=ResumeForm, template_name="resumes/add.html"):
can_add_active = has_perm(request.user, 'resumes.add_resume')
if not any([request.user.profile.is_superuser,
can_add_active,
get_setting('module', 'resumes', 'usercanadd'),
(request.user.profile.is_member and get_setting('module', 'resumes', 'userresumesrequiresmembership'))
]):
raise Http403
if request.method == "POST":
form = form_class(request.POST or None, user=request.user)
if form.is_valid():
resume = form.save(commit=False)
# set it to pending if the user does not have add permission
if not can_add_active:
resume.status_detail = 'pending'
# set up the expiration time based on requested duration
now = datetime.now()
resume.expiration_dt = now + timedelta(days=resume.requested_duration)
resume = update_perms_and_save(request, form, resume)
# we need to save instance first since we need the id for the file path
if request.FILES:
resume.resume_file = request.FILES['resume_file']
resume.resume_file.file.seek(0)
resume.save()
EventLog.objects.log(instance=resume)
if request.user.is_authenticated():
messages.add_message(request, messages.SUCCESS, _('Successfully added %(r)s' % {'r':resume}))
# send notification to administrators
recipients = get_notice_recipients('module', 'resumes', 'resumerecipients')
if recipients:
if notification:
extra_context = {
'object': resume,
'request': request,
}
notification.send_emails(recipients,'resume_added', extra_context)
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('resume.thank_you'))
else:
return HttpResponseRedirect(reverse('resume', args=[resume.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form':form},
context_instance=RequestContext(request))
def email_script_errors(err_msg):
"""Send error message to us if any.
"""
script_recipient = get_script_support_emails()
if script_recipient:
email_context.update({
'subject':'Error Processing Corporate Membership Notices on %s' % (
site_url),
'content':'%s \n\nTime Submitted: %s\n' % (err_msg, nowstr),
'content_type':"text"})
notification.send_emails(script_recipient, 'corp_memb_notice_email',
email_context)
def add(request, form_class=ArticleForm,
category_form_class=CategoryForm,
template_name="articles/add.html"):
content_type = get_object_or_404(ContentType,
app_label='articles',
model='article')
if has_perm(request.user, 'articles.add_article'):
if request.method == "POST":
form = form_class(request.POST, user=request.user)
categoryform = category_form_class(content_type,
request.POST,
prefix='category')
if form.is_valid() and categoryform.is_valid():
article = form.save()
article.update_category_subcategory(
categoryform.cleaned_data['category'],
categoryform.cleaned_data['sub_category']
)
# add all permissions and save the model
update_perms_and_save(request, form, article)
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % article)
# send notification to administrator(s) and module recipient(s)
recipients = get_notice_recipients('module', 'articles', 'articlerecipients')
if recipients and notification:
notification.send_emails(recipients, 'article_added', {
'object': article,
'request': request,
})
return HttpResponseRedirect(reverse('article', args=[article.slug]))
else:
form = form_class(user=request.user)
initial_category_form_data = {
'app_label': 'articles',
'model': 'article',
'pk': 0,
}
categoryform = category_form_class(content_type,
initial=initial_category_form_data,
prefix='category')
return render_to_response(template_name, {'form': form,
'categoryform': categoryform,},
context_instance=RequestContext(request))
else:
raise Http403
def add(request, form_class=ResumeForm, template_name="resumes/add.html"):
can_add_active = has_perm(request.user, "resumes.add_resume")
if request.method == "POST":
form = form_class(request.POST, user=request.user)
if form.is_valid():
resume = form.save(commit=False)
# set it to pending if the user does not have add permission
if not can_add_active:
resume.status = 0
resume.status_detail = "pending"
# set up the expiration time based on requested duration
now = now_localized()
resume.expiration_dt = now + timedelta(days=resume.requested_duration)
resume = update_perms_and_save(request, form, resume)
log_defaults = {
"event_id": 351000,
"event_data": "%s (%d) added by %s" % (resume._meta.object_name, resume.pk, request.user),
"description": "%s added" % resume._meta.object_name,
"user": request.user,
"request": request,
"instance": resume,
}
EventLog.objects.log(**log_defaults)
if request.user.is_authenticated():
messages.add_message(request, messages.SUCCESS, "Successfully added %s" % resume)
# send notification to administrators
recipients = get_notice_recipients("module", "resumes", "resumerecipients")
if recipients:
if notification:
extra_context = {"object": resume, "request": request}
notification.send_emails(recipients, "resume_added", extra_context)
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse("resume.thank_you"))
else:
return HttpResponseRedirect(reverse("resume", args=[resume.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {"form": form}, context_instance=RequestContext(request))
def auto_update_paid_object(self, request, payment):
"""
Update the object after online payment is received.
"""
from datetime import datetime
try:
from tendenci.apps.notifications import models as notification
except:
notification = None
from tendenci.core.perms.utils import get_notice_recipients
from tendenci.addons.events.utils import email_admins
site_label = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
self_reg8n = get_setting('module', 'users', 'selfregistration')
payment_attempts = self.invoice.payment_set.count()
registrants = self.registrant_set.all().order_by('id')
for registrant in registrants:
#registrant.assign_mapped_fields()
if registrant.custom_reg_form_entry:
registrant.name = registrant.custom_reg_form_entry.__unicode__()
else:
registrant.name = ' '.join([registrant.first_name, registrant.last_name])
# only send email on success! or first fail
if payment.is_paid or payment_attempts <= 1:
notification.send_emails(
[self.registrant.email], # recipient(s)
'event_registration_confirmation', # template
{
'SITE_GLOBAL_SITEDISPLAYNAME': site_label,
'SITE_GLOBAL_SITEURL': site_url,
'site_label': site_label,
'site_url': site_url,
'self_reg8n': self_reg8n,
'reg8n': self,
'registrants': registrants,
'event': self.event,
'total_amount': self.invoice.total,
'is_paid': payment.is_paid,
},
True, # notice saved in db
)
#notify the admins too
email_admins(self.event, self.invoice.total, self_reg8n, self, registrants)
def send_admin_confirmation(self, event, reg8n_list, verbosity=0, **kwargs):
from tendenci.apps.notifications import models as notification
from tendenci.apps.site_settings.utils import get_setting
admin_emails = get_setting('module', 'events',
'admin_emails').strip()
if admin_emails:
admin_emails = admin_emails.split(',')
if admin_emails:
if verbosity == 2:
print('Sending confirmation to {}'.format(', '.join(admin_emails)))
context = {'event': event,
'reg8n_list': reg8n_list,}
context.update(kwargs)
notification.send_emails(admin_emails, 'event_email_abandoned_recap',
context)
def delete(self, *args, **kwargs):
# Related objects
# Import related objects here to prevent circular references
from tendenci.apps.pages.models import Page
from tendenci.apps.events.models import Event
from tendenci.apps.stories.models import Story
pages = Page.objects.filter(header_image=self.pk)
events = Event.objects.filter(image=self.pk)
stories = Story.objects.filter(image=self.pk)
# Set foreign key of related objects to None
for page in pages:
page.header_image = None
page.save()
for event in events:
event.image = None
event.save()
for story in stories:
story.image = None
story.save()
# roll back the transaction to fix the error for postgresql
#"current transaction is aborted, commands ignored until
# end of transaction block"
#connection._rollback() # comment it out because this line of code leads to IntegrityError for files that inherit File's model.
# send notification to administrator(s) and module recipient(s)
if self.file:
recipients = get_notice_recipients('module', 'files', 'filerecipients')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
if self.owner:
owner = self.owner.get_full_name() or self.owner
else:
owner = "Unknown"
if recipients and notification:
notification.send_emails(recipients, 'file_deleted', {
'object': self,
'author': owner,
'SITE_GLOBAL_SITEDISPLAYNAME': site_display_name,
})
# delete actual file; do not save() self.instance
self.file.delete(save=False)
# delete database record
super(File, self).delete(*args, **kwargs)
def save_model(self, request, object, form, change):
instance = form.save(commit=False)
instance = update_perms_and_save(request, form, instance)
# notifications
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients("module", "pages", "pagerecipients")
notice_type = "page_added"
if change:
notice_type = "page_edited"
if recipients:
if notification:
extra_context = {"object": instance, "request": request}
notification.send_emails(recipients, notice_type, extra_context)
return instance
def auto_update_paid_object(self, request, payment):
"""
Update the object after online payment is received.
"""
# email to admin
try:
from tendenci.apps.notifications import models as notification
except:
notification = None
from tendenci.apps.perms.utils import get_notice_recipients
recipients = get_notice_recipients('module', 'donations', 'donationsrecipients')
if recipients:
if notification:
extra_context = {
'donation': self,
'invoice': payment.invoice,
'request': request,
}
notification.send_emails(recipients,'donation_added', extra_context)
def group_delete(request, id, template_name="user_groups/delete.html"):
group = get_object_or_404(Group, pk=id)
if not has_perm(request.user,'user_groups.delete_group',group): raise Http403
if request.method == "POST":
# send notification to administrators
recipients = get_notice_recipients('module', 'groups', 'grouprecipients')
if recipients:
if notification:
extra_context = {
'object': group,
'request': request,
}
notification.send_emails(recipients,'group_deleted', extra_context)
EventLog.objects.log(instance=group)
group.delete()
return HttpResponseRedirect(reverse('group.search'))
(deleted_objects, count, perms_needed, protected) = get_deleted_objects(
[group], request.user)
object_name = group.label or group.name
if perms_needed or protected:
title = _("Cannot delete %(name)s") % {"name": object_name}
else:
title = _("Are you sure?")
return render_to_resp(request=request, template_name=template_name,
context={'group':group,
"title": title,
"object_name": object_name,
"deleted_objects": deleted_objects,
"perms_lacking": perms_needed,
"protected": protected,
"opts": group._meta,
})
def auto_update_paid_object(self, request, payment):
"""
Update the object after online payment is received.
"""
# email to admin
try:
from tendenci.apps.notifications import models as notification
except:
notification = None
from tendenci.apps.perms.utils import get_notice_recipients
recipients = get_notice_recipients('module', 'donations',
'donationsrecipients')
if recipients:
if notification:
extra_context = {
'donation': self,
'invoice': payment.invoice,
'request': request,
}
notification.send_emails(recipients, 'donation_added',
extra_context)
def send_emails(self, request_email):
# email notifications
if request_email.recipients:
site_display_name = get_setting('site', 'global',
'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
params = {
'SITE_GLOBAL_SITEDISPLAYNAME':
site_display_name,
'SITE_GLOBAL_SITEURL':
site_url,
'MODULE_DIRECTORIES_LABEL_PLURAL':
get_setting('module', 'directories', 'label_plural'),
'directory':
self.to_directory,
'from_directory':
self.from_directory,
'message':
request_email.message,
'first_name':
request_email.sender.first_name,
'last_name':
request_email.sender.last_name,
'affiliate_request':
self.instance.affiliate_request,
}
# to to_directory owner
params['reply_to'] = request_email.sender.email
notification.send_emails(request_email.recipients,
'affiliate_requested_to_owner', params)
# to submitter
submitter_email = (request_email.sender.email).strip()
params['reply_to'] = request_email.recipients[0]
notification.send_emails([submitter_email],
'affiliate_requested_to_submitter',
params)
def add(request, form_class=NewsForm, template_name="news/add.html"):
# check permission
if not has_perm(request.user, 'news.add_news'):
raise Http403
if request.method == "POST":
form = form_class(request.POST, request.FILES, user=request.user)
if form.is_valid():
news = form.save(commit=False)
# update all permissions and save the model
news = update_perms_and_save(request, form, news)
# save photo
photo = form.cleaned_data['photo_upload']
if photo:
news.save(photo=photo)
assign_files_perms(news, files=[news.thumbnail])
msg_string = 'Successfully added %s' % news
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrators
recipients = get_notice_recipients('module', 'news', 'newsrecipients')
if recipients:
if notification:
extra_context = {
'object': news,
'request': request,
}
notification.send_emails(recipients, 'news_added', extra_context)
return HttpResponseRedirect(reverse('news.detail', args=[news.slug]))
else:
form = form_class(user=request.user)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def email_notice(self, event, registration, verbosity=0, **kwargs):
from tendenci.apps.notifications import models as notification
from tendenci.apps.base.utils import validate_email
registrant = registration.registrant
if registrant and registrant.email and validate_email(
registrant.email):
recipient = registrant.email
if recipient:
if verbosity == 2:
print('Sending notice email to {}'.format(recipient))
context = {
'event': event,
'invoice': registration.invoice,
'reg8n': registration,
'registrant': registrant.user,
}
context.update(kwargs)
notification.send_emails([recipient], 'event_email_abandoned',
context)
return True
def send_admin_confirmation(self,
event,
reg8n_list,
verbosity=0,
**kwargs):
from tendenci.apps.notifications import models as notification
from tendenci.apps.site_settings.utils import get_setting
admin_emails = get_setting('module', 'events', 'admin_emails').strip()
if admin_emails:
admin_emails = admin_emails.split(',')
if admin_emails:
if verbosity == 2:
print('Sending confirmation to {}'.format(
', '.join(admin_emails)))
context = {
'event': event,
'reg8n_list': reg8n_list,
}
context.update(kwargs)
notification.send_emails(admin_emails,
'event_email_abandoned_recap', context)
def group_delete(request, id, template_name="user_groups/delete.html"):
group = get_object_or_404(Group, pk=id)
if not has_perm(request.user,'user_groups.delete_group',group): raise Http403
if request.method == "POST":
# send notification to administrators
recipients = get_notice_recipients('module', 'groups', 'grouprecipients')
if recipients:
if notification:
extra_context = {
'object': group,
'request': request,
}
notification.send_emails(recipients,'group_deleted', extra_context)
EventLog.objects.log(instance=group)
group.delete()
return HttpResponseRedirect(reverse('group.search'))
return render_to_response(template_name, {'group':group},
context_instance=RequestContext(request))
def email_admins(event, total_amount, self_reg8n, reg8n, registrants):
site_label = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
admins = get_setting('module', 'events', 'admin_emails').split(',')
notice_recipients = get_setting('site', 'global', 'allnoticerecipients').split(',')
email_list = [admin.strip() for admin in admins] + [recipient.strip() for recipient in notice_recipients]
notification.send_emails(
email_list,
'event_registration_confirmation',
{
'SITE_GLOBAL_SITEDISPLAYNAME': site_label,
'SITE_GLOBAL_SITEURL': site_url,
'self_reg8n': self_reg8n,
'reg8n': reg8n,
'registrants': registrants,
'event': event,
'total_amount': total_amount,
'is_paid': reg8n.invoice.balance == 0,
'reg8n_number': reg8n.registrant_set.all().count(),
'for_admin': True,
},
True, # save notice in db
)
def save(self, *args, **kwargs):
created = False
if not self.id:
self.guid = unicode(uuid.uuid1())
created = True
self.f_type = self.type()
super(File, self).save(*args, **kwargs)
if self.is_public_file():
set_s3_file_permission(self.file, public=True)
else:
set_s3_file_permission(self.file, public=False)
cache_set = cache.get("files_cache_set.%s" % self.pk)
if cache_set is not None:
# TODO remove cached images
cache.delete_many(cache.get("files_cache_set.%s" % self.pk))
cache.delete("files_cache_set.%s" % self.pk)
# send notification to administrator(s) and module recipient(s)
if created:
recipients = get_notice_recipients('module', 'files', 'filerecipients')
site_display_name = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
if recipients and notification:
notification_params = {
'object': self,
'SITE_GLOBAL_SITEDISPLAYNAME': site_display_name,
'SITE_GLOBAL_SITEURL': site_url,
}
if self.owner:
notification_params['author'] = self.owner.get_full_name() or self.owner
notification.send_emails(recipients, 'file_added', notification_params)
def add(request, form_class=HelpFileForm, template_name="help_files/add.html"):
if has_perm(request.user, 'help_files.add_helpfile'):
if request.method == "POST":
form = form_class(request.POST, user=request.user)
if form.is_valid():
help_file = form.save(commit=False)
if not request.user.is_superuser:
help_file.status_detail = 'pending'
# add all permissions and save the model
help_file = update_perms_and_save(request, form, help_file)
form.save_m2m()
msg_string = 'Successfully added %s' % help_file
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrator(s) and module recipient(s)
if not request.user.is_superuser:
recipients = get_notice_recipients('module', 'help_files',
'helpfilerecipients')
if recipients:
notification.send_emails(recipients, 'help_file_added',
{
'object': help_file,
'request': request,
})
return HttpResponseRedirect(
reverse('help_file.details', args=[help_file.slug]))
else:
form = form_class(user=request.user)
return render_to_resp(request=request,
template_name=template_name,
context={'form': form})
else:
raise Http403
def send_registrant_email(reg8n, self_reg8n):
"""
Email registrant about his/her registration
"""
site_label = get_setting('site', 'global', 'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
primary_registrant = reg8n.registrant
if primary_registrant and primary_registrant.email:
notification.send_emails(
[primary_registrant.email],
'event_registration_confirmation',
{
'SITE_GLOBAL_SITEDISPLAYNAME': site_label,
'SITE_GLOBAL_SITEURL': site_url,
'self_reg8n': self_reg8n,
'reg8n': reg8n,
'event': reg8n.event,
'price': reg8n.amount_paid,
'is_paid': reg8n.invoice.balance == 0
},
True, # save notice in db
)
def send_welcome_email(user):
"""
Send email to user account.
Expects user account else returns false.
"""
from django.utils.http import int_to_base36
from django.contrib.auth.tokens import default_token_generator
from tendenci.apps.site_settings.utils import get_setting
token_generator = default_token_generator
site_url = get_setting('site', 'global', 'siteurl')
site_name = get_setting('site', 'global', 'sitedisplayname')
# send new user account welcome email (notification)
send_emails(
[user.email], 'user_welcome', {
'site_url': site_url,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'username': user.username,
'token': token_generator.make_token(user),
})
def email_member(notice, membership, global_context):
user = membership.user
body = notice.email_content
context = membership.get_field_items()
context['membership'] = membership
context.update(global_context)
# corporate member corp_replace_str
if membership.corporate_membership_id:
context['corporate_membership_notice'] = corp_replace_str
if membership.expire_dt:
context.update({
'expire_dt':
time.strftime("%d-%b-%y %I:%M %p",
membership.expire_dt.timetuple()),
})
if membership.payment_method:
payment_method_name = membership.payment_method.human_name
else:
payment_method_name = ''
context.update({
'member_number':
membership.member_number,
'payment_method':
payment_method_name,
'referer_url':
'%s%s?next=%s' %
(site_url, reverse('auth_login'), membership.referer_url),
'membership_link':
'%s%s' % (site_url, membership.get_absolute_url()),
'view_link':
'%s%s' % (site_url, membership.get_absolute_url()),
'renew_link':
'%s%s' % (site_url, membership.get_absolute_url()),
'mymembershipslink':
'%s%s' % (site_url, membership.get_absolute_url()),
'membershiplink':
'%s%s' % (site_url, membership.get_absolute_url()),
'renewlink':
'%s%s' % (site_url, membership.get_absolute_url())
})
body = fieldify(body)
body = body + ' <br /><br />{% include "email_footer.html" %}'
template = engines['django'].from_string(body)
body = template.render(context=context)
email_recipient = user.email
subject = notice.subject.replace('(name)', user.get_full_name())
template = engines['django'].from_string(subject)
subject = template.render(context=context)
email_context.update({'subject': subject, 'content': body})
if notice.sender:
email_context.update({
#'sender':notice.sender,
'reply_to': notice.sender
})
if notice.sender_display:
email_context.update({'sender_display': notice.sender_display})
notification.send_emails([email_recipient],
'membership_notice_email', email_context)
if verbosity > 1:
print('To ', email_recipient, subject)
def add(request, form_class=JobForm, template_name="jobs/add.html",
object_type=Job, success_redirect='job', thankyou_redirect='job.thank_you'):
require_payment = get_setting('module', 'jobs',
'jobsrequirespayment')
can_add_active = has_perm(request.user, 'jobs.add_job')
content_type = get_object_or_404(
ContentType,
app_label=object_type._meta.app_label,
model=object_type._meta.module_name
)
if request.user.profile.is_superuser:
category_form_class = CategoryForm
else:
category_form_class = CategoryForm2
form = form_class(request.POST or None, request.FILES or None, user=request.user)
# adjust the fields depending on user type
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if require_payment:
is_free = is_free_listing(request.user,
request.POST.get('pricing', 0),
request.POST.get('list_type'))
if is_free:
del form.fields['payment_method']
categoryform = category_form_class(
content_type,
request.POST,
prefix='category')
if form.is_valid() and categoryform.is_valid():
job = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if require_payment and is_free:
job.payment_method = 'paid - cc'
# set it to pending if the user is anonymous or not an admin
if not can_add_active:
#job.status = 1
job.status_detail = 'pending'
# list types and duration
if not job.requested_duration:
job.requested_duration = 30
if not job.list_type:
job.list_type = 'regular'
# set up all the times
now = datetime.now()
job.activation_dt = now
if not job.post_dt:
job.post_dt = now
# set the expiration date
job.expiration_dt = job.activation_dt + timedelta(
days=job.requested_duration)
# semi-anon job posts don't get a slug field on the form
# see __init__ method in JobForm
if not job.slug:
#job.slug = get_job_unique_slug(slugify(job.title))
job.slug = '%s-%s' % (slugify(job.title),
object_type.objects.count())
job = update_perms_and_save(request, form, job)
# create invoice
job_set_inv_payment(request.user, job, pricing)
#setup categories
category = Category.objects.get_for_object(job, 'category')
sub_category = Category.objects.get_for_object(
job, 'sub_category')
## update the category of the job
category_removed = False
category = categoryform.cleaned_data['category']
if category != '0':
Category.objects.update(job, category, 'category')
else: # remove
category_removed = True
Category.objects.remove(job, 'category')
Category.objects.remove(job, 'sub_category')
if not category_removed:
# update the sub category of the job
sub_category = categoryform.cleaned_data['sub_category']
if sub_category != '0':
Category.objects.update(job, sub_category,
'sub_category')
else: # remove
Category.objects.remove(job,'sub_category')
#save relationships
job.save()
msg_string = 'Successfully added %s' % job
messages.add_message(request, messages.SUCCESS,_(msg_string))
# send notification to administrators
recipients = get_notice_recipients(
'module', 'jobs', 'jobrecipients')
if recipients:
if notification:
extra_context = {
'object': job,
'request': request,
}
notification.send_emails(recipients, 'job_added',
extra_context)
# send user to the payment page if payment is required
if require_payment:
if job.payment_method.lower() in ['credit card', 'cc']:
if job.invoice and job.invoice.balance > 0:
return HttpResponseRedirect(reverse(
'payment.pay_online',
args=[job.invoice.id, job.invoice.guid])
)
# send user to thank you or view page
if request.user.profile.is_superuser:
return HttpResponseRedirect(
reverse(success_redirect, args=[job.slug]))
else:
return HttpResponseRedirect(reverse(thankyou_redirect))
else:
# Redirect user w/perms to create pricing if none exist
pricings = JobPricing.objects.all()
if not pricings and has_perm(request.user, 'jobs.add_jobpricing'):
msg_string = 'You need to add a %s Pricing before you can add a %s.' % (get_setting('module', 'jobs', 'label_plural'),get_setting('module', 'jobs', 'label'))
messages.add_message(request, messages.WARNING, _(msg_string))
return HttpResponseRedirect(reverse('job_pricing.add'))
initial_category_form_data = {
'app_label': 'jobs',
'model': 'job',
'pk': 0, #not used for this view but is required for the form
}
categoryform = category_form_class(
content_type,
initial=initial_category_form_data,
prefix='category')
return render_to_response(template_name,
{'form': form,
'require_payment': require_payment,
'categoryform': categoryform},
context_instance=RequestContext(request))
def add(request, form_class=ResumeForm, template_name="resumes/add.html"):
can_add_active = has_perm(request.user, 'resumes.add_resume')
if not any([
request.user.profile.is_superuser, can_add_active,
get_setting('module', 'resumes', 'usercanadd'),
(request.user.profile.is_member
and get_setting('module', 'resumes', 'userresumesrequiresmembership'))
]):
raise Http403
if request.method == "POST":
form = form_class(request.POST or None, user=request.user)
if form.is_valid():
resume = form.save(commit=False)
# set it to pending if the user does not have add permission
if not can_add_active:
resume.status_detail = 'pending'
# set up the expiration time based on requested duration
now = datetime.now()
resume.expiration_dt = now + timedelta(
days=resume.requested_duration)
resume = update_perms_and_save(request, form, resume)
# we need to save instance first since we need the id for the file path
if request.FILES:
resume.resume_file = request.FILES['resume_file']
resume.resume_file.file.seek(0)
resume.save()
EventLog.objects.log(instance=resume)
if request.user.is_authenticated:
messages.add_message(
request, messages.SUCCESS,
_('Successfully added %(r)s' % {'r': resume}))
# send notification to administrators
recipients = get_notice_recipients('module', 'resumes',
'resumerecipients')
if recipients:
if notification:
extra_context = {
'object': resume,
'request': request,
}
notification.send_emails(recipients, 'resume_added',
extra_context)
if not request.user.is_authenticated:
return HttpResponseRedirect(reverse('resume.thank_you'))
else:
return HttpResponseRedirect(
reverse('resume', args=[resume.slug]))
else:
form = form_class(user=request.user)
return render_to_resp(request=request,
template_name=template_name,
context={'form': form})
def group_add_edit(request,
group_slug=None,
form_class=GroupForm,
template_name="user_groups/add_edit.html"):
add, edit = False, False
if group_slug:
group = get_object_or_404(Group, slug=group_slug)
if not has_perm(request.user, 'user_groups.change_group', group):
raise Http403
title = _("Edit Group")
edit = True
else:
group = None
if not has_perm(request.user, 'user_groups.add_group'): raise Http403
title = _("Add Group")
add = True
if request.method == 'POST':
if edit:
form = form_class(request.POST, instance=group, user=request.user)
else:
form = form_class(request.POST, user=request.user)
if form.is_valid():
group = form.save(commit=False)
if not group.id:
group.creator = request.user
group.creator_username = request.user.username
# set up user permission
group.allow_user_view, group.allow_user_edit = form.cleaned_data[
'user_perms']
group.owner = request.user
group.owner_username = request.user.username
group = form.save()
if add:
# send notification to administrators
recipients = get_notice_recipients('module', 'groups',
'grouprecipients')
if recipients:
if notification:
extra_context = {
'object': group,
'request': request,
}
notification.send_emails(recipients, 'group_added',
extra_context)
EventLog.objects.log(instance=group)
return HttpResponseRedirect(group.get_absolute_url())
else:
if edit:
form = form_class(instance=group, user=request.user)
else:
form = form_class(user=request.user)
return render_to_resp(request=request,
template_name=template_name,
context={
'form': form,
'titie': title,
'group': group
})
def add(request,
form_class=ArticleForm,
category_form_class=CategoryForm,
template_name="articles/add.html"):
content_type = get_object_or_404(ContentType,
app_label='articles',
model='article')
if has_perm(request.user, 'articles.add_article'):
if request.method == "POST":
form = form_class(request.POST,
request.FILES or None,
user=request.user)
categoryform = category_form_class(
content_type,
request.POST,
)
if form.is_valid() and categoryform.is_valid():
article = form.save()
article.creator = request.user
article.creator_username = request.user.username
# add all permissions
update_perms_and_save(request, form, article)
article.update_category_subcategory(
categoryform.cleaned_data['category'],
categoryform.cleaned_data['sub_category'])
msg_string = 'Successfully added %s' % str(article)
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrator(s) and module recipient(s)
recipients = get_notice_recipients('module', 'articles',
'articlerecipients')
if recipients and notification:
notification.send_emails(recipients, 'article_added', {
'object': article,
'request': request,
})
return HttpResponseRedirect(
reverse('article', args=[article.slug]))
else:
form = form_class(user=request.user)
initial_category_form_data = {
'app_label': 'articles',
'model': 'article',
'pk': 0,
}
categoryform = category_form_class(
content_type,
initial=initial_category_form_data,
)
return render_to_resp(request=request,
template_name=template_name,
context={
'form': form,
'categoryform': categoryform,
})
else:
raise Http403
def index(request, form_class=SubmitContactForm, template_name="form.html"):
if request.method == "GET":
# event-log view
EventLog.objects.log(instance=Contact(), action='viewed')
if request.method == "POST":
event_log_dict = {}
form = form_class(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
if listed_in_email_block(email):
# listed in the email blocks - it's a spam email we want to block
# log the spam
EventLog.objects.log()
# redirect normally so they don't suspect
return HttpResponseRedirect(reverse('form.confirmation'))
address = form.cleaned_data.get('address')
city = form.cleaned_data.get('city')
state = form.cleaned_data.get('state')
zipcode = form.cleaned_data.get('zipcode')
country = form.cleaned_data.get('country')
phone = form.cleaned_data.get('phone')
url = form.cleaned_data.get('url')
message = form.cleaned_data.get('message')
exists = User.objects.filter(
first_name__iexact=first_name,
last_name__iexact=last_name,
email__iexact=email,
).exists()
if request.user.is_anonymous():
username = first_name.replace(' ', '')
if last_name:
username = username + '_' + last_name.replace(' ', '')
username = username.lower()
try:
User.objects.get(username=username)
x = User.objects.filter(first_name=first_name).count()
username = username + '_' + unicode(x)
except User.DoesNotExist:
pass
contact_user = User(
username=username,
email=email,
first_name=first_name,
last_name=last_name,
)
contact_user.is_active = False
contact_user.save()
profile = Profile(user=contact_user,
owner=contact_user,
creator=User.objects.get(pk=1),
address=address,
country=country,
city=city,
state=state,
url=url,
phone=phone,
zipcode=zipcode)
profile.save()
sf_id = create_salesforce_contact(profile)
# if exists:
# event_log_dict['description'] = 'logged-out submission as existing user'
# else:
event_log_dict[
'description'] = 'logged-out submission as new user'
else: # logged in user
self_submit = all([
request.user.first_name.lower().strip() ==
first_name.lower().strip(),
request.user.last_name.lower().strip() ==
last_name.lower().strip(),
request.user.email.lower().strip() ==
email.lower().strip(),
])
contact_user = request.user
if exists:
if self_submit:
event_log_dict[
'description'] = 'logged-in submission as self'
else:
event_log_dict[
'description'] = 'logged-in submission as existing user'
else:
event_log_dict[
'description'] = 'logged-in submission as non-existing user'
contact_kwargs = {
'first_name': first_name,
'last_name': last_name,
'message': message,
'user': contact_user,
}
contact = Contact(**contact_kwargs)
contact.allow_anonymous_view = False
contact.save()
if address or city or state or zipcode or country:
address_kwargs = {
'address': address,
'city': city,
'state': state,
'zipcode': zipcode,
'country': country,
}
obj_address = Address(**address_kwargs)
obj_address.save() # saves object
contact.addresses.add(obj_address) # saves relationship
if phone:
obj_phone = Phone(number=phone)
obj_phone.save() # saves object
contact.phones.add(obj_phone) # saves relationship
if email:
obj_email = Email(email=email)
obj_email.save() # saves object
contact.emails.add(obj_email) # saves relationship
if url:
obj_url = URL(url=url)
obj_url.save() # saves object
contact.urls.add(obj_url) # saves relationship
site_name = get_setting('site', 'global', 'sitedisplayname')
message_link = get_setting('site', 'global', 'siteurl')
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'contacts',
'contactrecipients')
if recipients:
if notification:
extra_context = {
'reply_to': email,
'contact': contact,
'first_name': first_name,
'last_name': last_name,
'address': address,
'city': city,
'state': state,
'zipcode': zipcode,
'country': country,
'phone': phone,
'email': email,
'url': url,
'message': message,
'message_link': message_link,
'site_name': site_name,
}
notification.send_emails(recipients, 'contact_submitted',
extra_context)
# event-log (logged in)
event_log = EventLog.objects.log(instance=contact,
user=contact_user,
action='submitted',
**event_log_dict)
event_log.url = contact.get_absolute_url()
event_log.save()
return HttpResponseRedirect(reverse('form.confirmation'))
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
form = form_class()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def edit(request,
id,
form_class=StudyGroupForm,
meta_form_class=MetaForm,
category_form_class=CategoryForm,
template_name="studygroups/edit.html"):
study_group = get_object_or_404(StudyGroup, pk=id)
if not has_perm(request.user, 'studygroups.change_studygroup',
study_group):
raise Http403
content_type = get_object_or_404(ContentType,
app_label='studygroups',
model='studygroup')
#setup categories
category = Category.objects.get_for_object(study_group, 'category')
sub_category = Category.objects.get_for_object(study_group, 'sub_category')
initial_category_form_data = {
'app_label': 'studygroups',
'model': 'studygroup',
'pk': study_group.pk,
'category': getattr(category, 'name', '0'),
'sub_category': getattr(sub_category, 'name', '0')
}
OfficerFormSet = inlineformset_factory(StudyGroup,
Officer,
form=OfficerForm,
extra=1)
OfficerFormSet.form = staticmethod(
curry(OfficerForm, study_group_group=study_group.group))
if request.method == "POST":
form = form_class(request.POST,
request.FILES,
instance=study_group,
user=request.user)
metaform = meta_form_class(request.POST,
instance=study_group.meta,
prefix='meta')
categoryform = category_form_class(content_type,
request.POST,
initial=initial_category_form_data,
prefix='category')
formset = OfficerFormSet(request.POST,
instance=study_group,
prefix="officers")
if form.is_valid() and metaform.is_valid() and categoryform.is_valid(
) and formset.is_valid():
study_group = form.save(commit=False)
# update all permissions and save the model
study_group = update_perms_and_save(request, form, study_group)
#save meta
meta = metaform.save()
study_group.meta = meta
officers = formset.save()
## update the category of the studygroup
category_removed = False
category = categoryform.cleaned_data['category']
if category != '0':
Category.objects.update(study_group, category, 'category')
else: # remove
category_removed = True
Category.objects.remove(study_group, 'category')
Category.objects.remove(study_group, 'sub_category')
if not category_removed:
# update the sub category of the studygroup
sub_category = categoryform.cleaned_data['sub_category']
if sub_category != '0':
Category.objects.update(study_group, sub_category,
'sub_category')
else: # remove
Category.objects.remove(study_group, 'sub_category')
#save relationships
study_group.save()
EventLog.objects.log(instance=study_group)
messages.add_message(request, messages.SUCCESS,
'Successfully updated %s' % study_group)
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients('module', 'studygroups',
'studygrouprecipients')
if recipients:
if notification:
extra_context = {
'object': study_group,
'request': request,
}
notification.send_emails(recipients,
'study_group_edited',
extra_context)
return HttpResponseRedirect(
reverse('studygroups.detail', args=[study_group.slug]))
else:
form = form_class(instance=study_group, user=request.user)
metaform = meta_form_class(instance=study_group.meta, prefix='meta')
categoryform = category_form_class(content_type,
initial=initial_category_form_data,
prefix='category')
formset = OfficerFormSet(instance=study_group, prefix="officers")
#formset.form = staticmethod(curry(OfficerForm, study_group_group=study_group.group))
return render_to_response(template_name, {
'study_group': study_group,
'form': form,
'metaform': metaform,
'categoryform': categoryform,
'formset': formset,
},
context_instance=RequestContext(request))
def add(request, form_class=DonationForm, template_name="donations/add.html"):
use_captcha = get_setting('site', 'global', 'captcha')
if request.method == "POST":
form = form_class(request.POST, user=request.user)
captcha_form = CaptchaForm(request.POST)
if not use_captcha:
del captcha_form.fields['captcha']
if form.is_valid() and captcha_form.is_valid():
donation = form.save(commit=False)
donation.payment_method = donation.payment_method.lower()
# we might need to create a user record if not exist
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(email=donation.email)
except:
user = request.user
if not user.is_anonymous():
donation.user = user
donation.creator = user
donation.creator_username = user.username
else:
# this is anonymous user donating and we didn't find their user record in the system,
# so add a new user
user = User()
user.first_name = donation.first_name
user.last_name = donation.last_name
user.email = donation.email
user.username = get_unique_username(user)
user.set_password(User.objects.make_random_password(length=8))
user.is_active = 0
user.save()
profile_kwarg = {'user':user,
'company':donation.company,
'address':donation.address,
'address2':donation.address2,
'city':donation.city,
'state':donation.state,
'zipcode':donation.zip_code,
'country':donation.country,
'phone':donation.phone}
if request.user.is_anonymous():
profile_kwarg['creator'] = user
profile_kwarg['creator_username'] = user.username
profile_kwarg['owner'] = user
profile_kwarg['owner_username'] = user.username
else:
profile_kwarg['creator'] = request.user
profile_kwarg['creator_username'] = request.user.username
profile_kwarg['owner'] = request.user
profile_kwarg['owner_username'] = request.user.username
profile = Profile.objects.create(**profile_kwarg)
profile.save()
donation.save(user)
# create invoice
invoice = donation_inv_add(user, donation)
# updated the invoice_id for mp, so save again
donation.save(user)
if request.user.profile.is_superuser:
if donation.payment_method in ['paid - check', 'paid - cc']:
# the admin accepted payment - mark the invoice paid
invoice.tender(request.user)
invoice.make_payment(request.user, donation.donation_amount)
# send notification to administrators
# get admin notice recipients
if not donation.payment_method.lower() in ['cc', 'credit card', 'paypal']:
# email to admin (if payment type is credit card email is not sent until payment confirmed)
recipients = get_notice_recipients('module', 'donations', 'donationsrecipients')
if recipients:
if notification:
extra_context = {
'donation': donation,
'invoice': invoice,
'request': request,
}
notification.send_emails(recipients,'donation_added', extra_context)
# email to user
email_receipt = form.cleaned_data['email_receipt']
if email_receipt:
donation_email_user(request, donation, invoice)
EventLog.objects.log(instance=donation)
# redirect to online payment or confirmation page
if donation.payment_method.lower() in ['cc', 'credit card', 'paypal']:
return HttpResponseRedirect(reverse('payment.pay_online', args=[invoice.id, invoice.guid]))
else:
return HttpResponseRedirect(reverse('donation.add_confirm', args=[donation.id]))
else:
form = form_class(user=request.user)
captcha_form = CaptchaForm()
currency_symbol = get_setting("site", "global", "currencysymbol")
if not currency_symbol: currency_symbol = "$"
return render_to_response(template_name, {
'form':form,
'captcha_form' : captcha_form,
'use_captcha' : use_captcha,
'currency_symbol': currency_symbol},
context_instance=RequestContext(request))
def add(request,
form_class=StudyGroupForm,
meta_form_class=MetaForm,
category_form_class=CategoryForm,
template_name="studygroups/add.html"):
if not has_perm(request.user, 'studygroups.add_studygroup'):
raise Http403
content_type = get_object_or_404(ContentType,
app_label='studygroups',
model='studygroup')
#OfficerFormSet = inlineformset_factory(StudyGroup, Officer, form=OfficerForm, extra=1)
if request.method == 'POST':
form = form_class(request.POST, request.FILES, user=request.user)
metaform = meta_form_class(request.POST, prefix='meta')
categoryform = category_form_class(content_type,
request.POST,
prefix='category')
#formset = OfficerFormSet(request.POST, prefix="officers")
if form.is_valid() and metaform.is_valid() and categoryform.is_valid():
study_group = form.save(commit=False)
study_group = update_perms_and_save(request, form, study_group)
#save meta
meta = metaform.save()
study_group.meta = meta
#setup categories
category = Category.objects.get_for_object(study_group, 'category')
sub_category = Category.objects.get_for_object(
study_group, 'sub_category')
## update the category of the studygroup
category_removed = False
category = categoryform.cleaned_data['category']
if category != '0':
Category.objects.update(study_group, category, 'category')
else: # remove
category_removed = True
Category.objects.remove(study_group, 'category')
Category.objects.remove(study_group, 'sub_category')
if not category_removed:
# update the sub category of the studygroup
sub_category = categoryform.cleaned_data['sub_category']
if sub_category != '0':
Category.objects.update(study_group, sub_category,
'sub_category')
else: # remove
Category.objects.remove(study_group, 'sub_category')
#save relationships
study_group.save()
EventLog.objects.log()
messages.add_message(request, messages.SUCCESS,
'Successfully added %s' % study_group)
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients('module', 'studygroups',
'studygrouprecipients')
if recipients:
if notification:
extra_context = {
'object': study_group,
'request': request,
}
notification.send_emails(recipients,
'study_group_added',
extra_context)
return HttpResponseRedirect(
reverse('studygroups.detail', args=[study_group.slug]))
else:
initial_category_form_data = {
'app_label': 'studygroups',
'model': 'studygroup',
'pk': 0, #not used for this view but is required for the form
}
form = form_class(user=request.user)
metaform = meta_form_class(prefix='meta')
categoryform = category_form_class(content_type,
initial=initial_category_form_data,
prefix='category')
return render_to_response(template_name, {
'form': form,
'metaform': metaform,
'categoryform': categoryform,
},
context_instance=RequestContext(request))
def add(request, form_class=DirectoryForm, template_name="directories/add.html"):
can_add_active = has_perm(request.user,'directories.add_directory')
if not any([request.user.profile.is_superuser,
can_add_active,
get_setting('module', 'directories', 'usercanadd'),
(request.user.profile.is_member and get_setting('module', 'directories', 'directoriesrequiresmembership'))
]):
raise Http403
require_payment = get_setting('module', 'directories', 'directoriesrequirespayment')
form = form_class(request.POST or None, request.FILES or None, user=request.user)
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if form.is_valid():
directory = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if directory.payment_method:
directory.payment_method = directory.payment_method.lower()
if not directory.requested_duration:
directory.requested_duration = 30
if not directory.list_type:
directory.list_type = 'regular'
if not directory.slug:
directory.slug = '%s-%s' % (slugify(directory.headline), Directory.objects.count())
if not can_add_active:
directory.status = True
directory.status_detail = 'pending'
else:
directory.activation_dt = datetime.now()
# set the expiration date
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
if directory.logo:
directory.logo.file.seek(0)
# update all permissions and save the model
directory = update_perms_and_save(request, form, directory)
# resize the image that has been uploaded
if directory.logo:
if settings.USE_S3_STORAGE:
resize_s3_image(directory.logo.name)
else:
try:
logo = Image.open(directory.logo.path)
logo.thumbnail((200,200),Image.ANTIALIAS)
logo.save(directory.logo.path)
except:
pass
# create invoice
directory_set_inv_payment(request.user, directory, pricing)
messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % directory)
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_added', extra_context)
if directory.payment_method.lower() in ['credit card', 'cc']:
if directory.invoice and directory.invoice.balance > 0:
return HttpResponseRedirect(reverse('payments.views.pay_online', args=[directory.invoice.id, directory.invoice.guid]))
if can_add_active:
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
else:
return HttpResponseRedirect(reverse('directory.thank_you'))
return render_to_response(template_name, {'form':form},
context_instance=RequestContext(request))
def add(request, form_class=DirectoryForm, template_name="directories/add.html"):
can_add_active = has_perm(request.user,'directories.add_directory')
if not any([request.user.profile.is_superuser,
can_add_active,
get_setting('module', 'directories', 'usercanadd'),
(request.user.profile.is_member and get_setting('module', 'directories', 'directoriesrequiresmembership'))
]):
raise Http403
pricings = DirectoryPricing.objects.filter(status=True)
if not pricings and has_perm(request.user, 'directories.add_directorypricing'):
msg_string = 'You need to add a %s Pricing before you can add %s.' % (get_setting('module', 'directories', 'label_plural'),get_setting('module', 'directories', 'label'))
messages.add_message(request, messages.WARNING, _(msg_string))
return HttpResponseRedirect(reverse('directory_pricing.add'))
require_payment = get_setting('module', 'directories', 'directoriesrequirespayment')
form = form_class(request.POST or None, request.FILES or None, user=request.user)
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if require_payment:
is_free = is_free_listing(request.user,
request.POST.get('pricing', 0),
request.POST.get('list_type'))
if is_free:
del form.fields['payment_method']
if form.is_valid():
directory = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if require_payment and is_free:
directory.payment_method = 'paid - cc'
if directory.payment_method:
directory.payment_method = directory.payment_method.lower()
if not directory.requested_duration:
directory.requested_duration = 30
if not directory.list_type:
directory.list_type = 'regular'
if not directory.slug:
directory.slug = '%s-%s' % (slugify(directory.headline), Directory.objects.count())
if not can_add_active:
directory.status = True
directory.status_detail = 'pending'
else:
directory.activation_dt = datetime.now()
# set the expiration date
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
directory = update_perms_and_save(request, form, directory)
# create invoice
directory_set_inv_payment(request.user, directory, pricing)
msg_string = 'Successfully added %s' % directory
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_added', extra_context)
if directory.payment_method.lower() in ['credit card', 'cc']:
if directory.invoice and directory.invoice.balance > 0:
return HttpResponseRedirect(reverse('payment.pay_online', args=[directory.invoice.id, directory.invoice.guid]))
if can_add_active:
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
else:
return HttpResponseRedirect(reverse('directory.thank_you'))
return render_to_response(template_name,
{'form': form,
'require_payment': require_payment},
context_instance=RequestContext(request))
def add(request, form_class=MakePaymentForm, template_name="make_payments/add.html"):
if request.method == "POST":
form = form_class(request.user, request.POST)
if form.is_valid():
mp = form.save(commit=False)
# we might need to create a user record if not exist
if request.user.is_authenticated:
user = request.user
else:
try:
user = User.objects.get(email=mp.email)
except:
user = request.user
if not user.is_anonymous:
mp.user = user
mp.creator = user
mp.creator_username = user.username
mp.save(user)
# create invoice
invoice = make_payment_inv_add(user, mp)
EventLog.objects.log(instance=invoice)
# updated the invoice_id for mp, so save again
mp.save(user)
EventLog.objects.log(instance=mp)
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'payments', 'paymentrecipients')
if recipients:
if notification:
extra_context = {
'mp': mp,
'invoice': invoice,
'request': request,
}
notification.send_emails(recipients,'make_payment_added', extra_context)
# email to user
email_receipt = form.cleaned_data['email_receipt']
if email_receipt:
make_payment_email_user(request, mp, invoice)
# redirect to online payment or confirmation page
if mp.payment_method == 'cc' or mp.payment_method == 'credit card':
return HttpResponseRedirect(reverse('payment.pay_online', args=[invoice.id, invoice.guid]))
else:
return HttpResponseRedirect(reverse('make_payment.add_confirm', args=[mp.id]))
else:
form = form_class(request.user)
# check for initial payment_amount and clean up
payment_amount = request.GET.get('payment_amount', 0)
try:
payment_amount = float(payment_amount)
except:
payment_amount = 0
if payment_amount > 0:
form.fields['payment_amount'].initial = payment_amount
# check for initial comment and clean up
comments = request.GET.get('comments','')
if comments:
comments = strip_html(comments)
form.fields['comments'].initial = comments
currency_symbol = get_setting("site", "global", "currencysymbol")
if not currency_symbol: currency_symbol = "$"
return render_to_resp(request=request, template_name=template_name,
context={'form':form, 'currency_symbol': currency_symbol})
def renew(request, id, form_class=DirectoryRenewForm, template_name="directories/renew.html"):
can_add_active = has_perm(request.user,'directories.add_directory')
require_approval = get_setting('module', 'directories', 'renewalrequiresapproval')
directory = get_object_or_404(Directory, pk=id)
if not has_perm(request.user,'directories.change_directory', directory) or not request.user == directory.creator:
raise Http403
# pop payment fields if not required
require_payment = get_setting('module', 'directories', 'directoriesrequirespayment')
form = form_class(request.POST or None, request.FILES or None, instance=directory, user=request.user)
if not require_payment:
del form.fields['payment_method']
del form.fields['list_type']
if request.method == "POST":
if form.is_valid():
directory = form.save(commit=False)
pricing = form.cleaned_data['pricing']
if directory.payment_method:
directory.payment_method = directory.payment_method.lower()
if not directory.requested_duration:
directory.requested_duration = 30
if not directory.list_type:
directory.list_type = 'regular'
if not directory.slug:
directory.slug = '%s-%s' % (slugify(directory.headline), Directory.objects.count())
if not can_add_active and require_approval:
directory.status = True
directory.status_detail = 'pending'
else:
directory.activation_dt = datetime.now()
# set the expiration date
directory.expiration_dt = directory.activation_dt + timedelta(days=directory.requested_duration)
# mark renewal as not sent for new exp date
directory.renewal_notice_sent = False
# update all permissions and save the model
directory = update_perms_and_save(request, form, directory)
# create invoice
directory_set_inv_payment(request.user, directory, pricing)
msg_string = 'Successfully renewed %s' % directory
messages.add_message(request, messages.SUCCESS, _(msg_string))
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'directories', 'directoryrecipients')
if recipients:
if notification:
extra_context = {
'object': directory,
'request': request,
}
notification.send_emails(recipients,'directory_renewed', extra_context)
if directory.payment_method.lower() in ['credit card', 'cc']:
if directory.invoice and directory.invoice.balance > 0:
return HttpResponseRedirect(reverse('payments.views.pay_online', args=[directory.invoice.id, directory.invoice.guid]))
if can_add_active:
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
else:
return HttpResponseRedirect(reverse('directory.thank_you'))
return render_to_response(template_name, {'directory':directory, 'form':form},
context_instance=RequestContext(request))
def email_member(notice, membership, global_context):
corp_profile = membership.corp_profile
representatives = corp_profile.reps.filter(Q(is_dues_rep=True)|(Q(is_member_rep=True)))
sent = 0
corp_app = CorpMembershipApp.objects.current_app()
authentication_info = render_to_string(
'notification/corp_memb_notice_email/auth_info.html',
{'corp_membership': membership,
'corp_app': corp_app})
individuals_join_url = '%s%s' % (site_url,
reverse('membership_default.corp_pre_add',
args=[membership.id]))
if membership.expiration_dt:
expire_dt = time.strftime("%d-%b-%y %I:%M %p",
membership.expiration_dt.timetuple())
else:
expire_dt = ''
if membership.payment_method:
payment_method = membership.payment_method.human_name
else:
payment_method = ''
if membership.renewal:
renewed_individuals_list = render_to_string(
'notification/corp_memb_notice_email/renew_list.html',
{'corp_membership': membership})
total_individuals_renewed = membership.indivmembershiprenewentry_set.count()
else:
renewed_individuals_list = ''
total_individuals_renewed = ''
if membership.invoice:
invoice_link = '%s%s' % (site_url,
membership.invoice.get_absolute_url())
else:
invoice_link = ''
global_context.update({
'name': corp_profile.name,
'email': corp_profile.email,
'expire_dt': expire_dt,
'payment_method': payment_method,
'renewed_individuals_list': renewed_individuals_list,
'total_individuals_renewed': total_individuals_renewed,
'view_link': "%s%s" % (site_url, membership.get_absolute_url()),
'renew_link': "%s%s" % (site_url, membership.get_renewal_url()),
'invoice_link': invoice_link,
'authentication_info': authentication_info,
'individuals_join_url': individuals_join_url,
})
for recipient in representatives:
body = notice.email_content
context = membership.get_field_items()
context['membership'] = membership
context.update(global_context)
context.update({
'rep_first_name': recipient.user.first_name,
})
body = fieldify(body)
body = '%s <br /><br />%s' % (body, get_footer())
context = Context(context)
template = Template(body)
body = template.render(context)
email_recipient = recipient.user.email
subject = notice.subject.replace('(name)',
corp_profile.name)
template = Template(subject)
subject = template.render(context)
email_context.update({
'subject':subject,
'content':body})
if notice.sender:
email_context.update({
'sender':notice.sender,
'reply_to':notice.sender})
if notice.sender_display:
email_context.update({'sender_display':notice.sender_display})
notification.send_emails([email_recipient], 'corp_memb_notice_email',
email_context)
sent += 1
if verbosity > 1:
print 'To ', email_recipient, subject
return sent
def edit(request,
id,
form_class=PageForm,
meta_form_class=MetaForm,
category_form_class=CategoryForm,
template_name="pages/edit.html"):
page = get_object_or_404(Page, pk=id)
if not has_perm(request.user, 'pages.change_page', page):
raise Http403
content_type = get_object_or_404(ContentType,
app_label='pages',
model='page')
if request.method == "POST":
form = form_class(request.POST,
request.FILES,
instance=page,
user=request.user)
# metaform = meta_form_class(request.POST,
# instance=page.meta,
# prefix='meta')
# categoryform = category_form_class(content_type,
# request.POST,)
if form.is_valid(
): # and metaform.is_valid() and categoryform.is_valid():
page = form.save()
# handle header image
# f = form.cleaned_data['header_image']
# if f:
# header = HeaderImage()
# header.content_type = ContentType.objects.get_for_model(Page)
# header.object_id = page.id
# header.creator = request.user
# header.creator_username = request.user.username
# header.owner = request.user
# header.owner_username = request.user.username
# filename = "%s-%s" % (page.slug, f.name)
# f.file.seek(0)
# header.file.save(filename, f)
# page.header_image = header
#save meta
# meta = metaform.save()
# page.meta = meta
## update the category and subcategory
# page.update_category_subcategory(
# categoryform.cleaned_data['category'],
# categoryform.cleaned_data['sub_category']
# )
# update all permissions
page = update_perms_and_save(request, form, page)
if page.pk == 1: # the about page has id 1 in the npo defaults fixture
checklist_update('update-about')
messages.add_message(
request, messages.SUCCESS,
_('Successfully updated %(p)s' % {'p': unicode(page)}))
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients('module', 'pages',
'pagerecipients')
if recipients:
if notification:
extra_context = {
'object': page,
'request': request,
}
notification.send_emails(recipients, 'page_edited',
extra_context)
return HttpResponseRedirect(reverse('page', args=[page.slug]))
else:
form = form_class(instance=page, user=request.user)
# metaform = meta_form_class(instance=page.meta, prefix='meta')
#setup categories
# category = Category.objects.get_for_object(page, 'category')
# sub_category = Category.objects.get_for_object(page, 'sub_category')
# initial_category_form_data = {
# 'app_label': 'pages',
# 'model': 'page',
# 'pk': page.pk,
# 'category': getattr(category, 'name', '0'),
# 'sub_category': getattr(sub_category, 'name', '0')
# }
#
# categoryform = category_form_class(content_type,
# initial=initial_category_form_data,)
return render_to_response(
template_name,
{
'page': page,
'form': form,
# 'metaform': metaform,
# 'categoryform': categoryform,
},
context_instance=RequestContext(request))
def activate(request,
activation_key,
template_name='registration/activate.html',
extra_context=None):
"""
Activate a ``User``'s account from an activation key, if their key
is valid and hasn't expired.
By default, use the template ``registration/activate.html``; to
change this, pass the name of a template as the keyword argument
``template_name``.
**Required arguments**
``activation_key``
The activation key to validate and use for activating the
``User``.
**Optional arguments**
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``template_name``
A custom template to use.
**Context:**
``account``
The ``User`` object corresponding to the account, if the
activation was successful. ``False`` if the activation was not
successful.
``expiration_days``
The number of days for which activation keys stay valid after
registration.
Any extra variables supplied in the ``extra_context`` argument
(see above).
**Template:**
registration/activate.html or ``template_name`` keyword argument.
"""
activation_key = activation_key.lower(
) # Normalize before trying anything with it.
account = RegistrationProfile.objects.activate_user(activation_key)
if account:
account.auto_login = True
credentials = {'username': '', 'password': '', 'user': account}
user = authenticate(**credentials)
login(request, user)
# send notification to administrators
recipients = get_notice_recipients('module', 'users', 'userrecipients')
if recipients:
if notification:
extra_context = {
'object': user.profile,
'request': request,
}
notification.send_emails(recipients, 'user_added',
extra_context)
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
next_url = request.GET.get('next', '')
if account and next_url:
return HttpResponseRedirect(next_url)
return render_to_response(
template_name, {
'account': account,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS
},
context_instance=context)
def add(request,
form_class=PageForm,
meta_form_class=MetaForm,
category_form_class=CategoryForm,
template_name="pages/add.html"):
if not has_perm(request.user, 'pages.add_page'):
raise Http403
content_type = get_object_or_404(ContentType,
app_label='pages',
model='page')
if request.method == "POST":
form = form_class(request.POST, request.FILES, user=request.user)
metaform = meta_form_class(request.POST, prefix='meta')
categoryform = category_form_class(
content_type,
request.POST,
)
if form.is_valid() and metaform.is_valid() and categoryform.is_valid():
page = form.save()
# handle header image
# f = form.cleaned_data['header_image']
# if f:
# header = HeaderImage()
# header.content_type = ContentType.objects.get_for_model(Page)
# header.object_id = page.id
# header.creator = request.user
# header.creator_username = request.user.username
# header.owner = request.user
# header.owner_username = request.user.username
# filename = "%s-%s" % (page.slug, f.name)
# f.file.seek(0)
# header.file.save(filename, f)
# page.header_image = header
#save meta
meta = metaform.save()
page.meta = meta
## update the category and subcategory
page.update_category_subcategory(
categoryform.cleaned_data['category'],
categoryform.cleaned_data['sub_category'])
# add all permissions
page = update_perms_and_save(request, form, page)
messages.add_message(
request, messages.SUCCESS,
_('Successfully added %(p)s' % {'p': unicode(page)}))
checklist_update('add-page')
if not request.user.profile.is_superuser:
# send notification to administrators
recipients = get_notice_recipients('module', 'pages',
'pagerecipients')
if recipients:
if notification:
extra_context = {
'object': page,
'request': request,
}
notification.send_emails(recipients, 'page_added',
extra_context)
if page.status and page.status_detail == 'active':
return HttpResponseRedirect(reverse('page', args=[page.slug]))
return HttpResponseRedirect(reverse('page.search'))
else:
initial_category_form_data = {
'app_label': 'pages',
'model': 'page',
'pk': 0,
}
form = form_class(user=request.user)
metaform = meta_form_class(prefix='meta')
categoryform = category_form_class(
content_type,
initial=initial_category_form_data,
)
return render_to_response(template_name, {
'form': form,
'metaform': metaform,
'categoryform': categoryform,
},
context_instance=RequestContext(request))
def approve(request, affiliate_request_id):
"""
Approve an affiliate request.
"""
if not get_setting('module', 'directories', 'affiliates_enabled'):
raise Http404
# Get the affiliate_request and directory
affiliate_request = get_object_or_404(AffiliateRequest,
id=affiliate_request_id)
directory = affiliate_request.to_directory
# Check user permission
if not directory.allow_approve_affiliations_by(request.user):
raise Http403
if request.method in ["POST"]:
from_directory = affiliate_request.from_directory
request_as = affiliate_request.request_as
if not Affiliateship.objects.filter(directory=directory,
affiliate=from_directory,
connected_as=request_as).exists():
# Add affiliate to the directory
Affiliateship.objects.create(directory=directory,
affiliate=from_directory,
connected_as=request_as,
creator=request.user)
# Email to the submitter of the affiliate request
site_display_name = get_setting('site', 'global',
'sitedisplayname')
site_url = get_setting('site', 'global', 'siteurl')
params = {
'SITE_GLOBAL_SITEDISPLAYNAME':
site_display_name,
'SITE_GLOBAL_SITEURL':
site_url,
'MODULE_DIRECTORIES_LABEL_PLURAL':
get_setting('module', 'directories', 'label_plural'),
'directory':
directory,
'from_directory':
from_directory,
'first_name':
affiliate_request.creator.first_name,
'reply_to':
request.user.email,
}
notification.send_emails([affiliate_request.creator.email],
'affiliate_approved_to_submitter', params)
# log an event
description = _(
'Approved affiliate request from {from_directory} to {to_directory}.'
).format(from_directory=from_directory, to_directory=directory)
EventLog.objects.log(instance=affiliate_request,
description=description)
msg_string = _(
f'Successfully accepted the affiliate request from {str(from_directory)} as {request_as}'
)
messages.add_message(request, messages.SUCCESS, msg_string)
# Remove the request
affiliate_request.delete()
if 'ajax' in request.POST:
return HttpResponse('Ok')
return HttpResponseRedirect(reverse('directory', args=[directory.slug]))
