def prepare_content_count(self, obj):
""" Upcoming events for this project/group """
try:
event_model = resolve_class('cosinnus_event.models.Event')
except ImportError:
return -1
return event_model.get_current(obj, AnonymousUser()).count()
def extra_forms(self):
if not hasattr(self, '_extra_forms'):
self._extra_forms = []
initial = hasattr(self, 'instance') and getattr(self.instance, self.extra_forms_field) or None
for form in getattr(settings, self.extra_forms_setting, []):
form_class = resolve_class(form)
if self.request.POST:
self._extra_forms.append(form_class(data=self.request.POST))
else:
self._extra_forms.append(form_class(initial=initial))
return self._extra_forms
def get_context_data(self, **kwargs):
context = super(GroupObjectCountMixin, self).get_context_data(**kwargs)
object_counts = {}
for app in app_registry:
app_name = app_registry.get_name(app)
if self.group.is_app_deactivated(app):
continue
if app in self.app_object_count_mappings:
model = resolve_class(self.app_object_count_mappings[app])
# only for counting the objects, we use a fake superuser, so we get the actual
# counts of the contents, and not the visible ones for current user
fake_admin = AnonymousUser()
fake_admin.is_superuser = True
object_counts[app_name] = model.get_current(
self.group, fake_admin).count()
context.update({
'object_counts': object_counts,
})
return context
def _import_second_round_relations(self,
item_data_list,
user_import_item,
dry_run=True):
""" Stub to support an additional, second import round for CSV items,
run after the main import has been processed and all items have been created.
Mainly enables things like group membership or tag assignments, which
wouldn't work on a single pass of the imported data because they may
reference data that follows further on in the CSV. """
pass
def get_user_report_title(self, item_data):
return 'Row: #' + str(item_data['ROW_NUM'] +
1) + ' <b>' + item_data.get(
self.field_name_map['first_name'],
'(no name)') + '</b> <i>' + item_data.get(
self.field_name_map['email'],
'(no email)') + '</i>'
class DryRunFinishedException(Exception):
""" An exception that rolls back an atomic block for a dry run when it has finished successfully. """
pass
# allow dropin of labels class
CosinnusUserImportProcessor = CosinnusUserImportProcessorBase
if getattr(settings, 'COSINNUS_USER_IMPORT_PROCESSOR_CLASS_DROPIN', None):
CosinnusUserImportProcessor = resolve_class(
settings.COSINNUS_USER_IMPORT_PROCESSOR_CLASS_DROPIN)
MESSAGE_ONLY_ADMINS_MAY_CREATE = _(
'Sorry, only portal administrators can create Conferences! You can write a message to one of the administrators to create a Conference for you. Below you can find a listing of all administrators.'
)
MESSAGE_ONLY_ADMINS_MAY_DEACTIVATE = _(
'Sorry, only portal administrators can deactivate Conferences! You can write a message to one of the administrators to deactivate it for you. Below you can find a listing of all administrators.'
)
MESSAGE_MEMBERS_ONLY = _(
'Only conference members can see the content you requested. Apply to become a member now!'
)
# allow dropin of trans classes
CosinnusProjectTrans = CosinnusProjectTransBase
if getattr(settings, 'COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS',
{}).get(0, None):
CosinnusProjectTrans = resolve_class(
settings.COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS[0])
CosinnusSocietyTrans = CosinnusSocietyTransBase
if getattr(settings, 'COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS',
{}).get(1, None):
CosinnusSocietyTrans = resolve_class(
settings.COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS[1])
CosinnusConferenceTrans = CosinnusConferenceTransBase
if getattr(settings, 'COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS',
{}).get(2, None):
CosinnusConferenceTrans = resolve_class(
settings.COSINNUS_GROUP_TRANS_TYPED_CLASSES_DROPINS[2])
GROUP_TRANS_MAP = {
0: CosinnusProjectTrans,
# in the select list, this is the "none chosen" choice string
MANAGED_TAG_FIELD_EMPTY_CHOICE = _('No Tag selected')
@classmethod
def get_labels_dict(cls):
""" Returns a dict of all labels.
Note: lazy translation objects will be resolved here! """
return dict([(key, force_text(val))
for (key, val) in cls.__dict__.items()
if not key.startswith('_')])
# allow dropin of labels class
MANAGED_TAG_LABELS = CosinnusManagedTagLabels
if getattr(settings, 'COSINNUS_MANAGED_TAGS_LABEL_CLASS_DROPIN', None):
MANAGED_TAG_LABELS = resolve_class(
settings.COSINNUS_MANAGED_TAGS_LABEL_CLASS_DROPIN)
class CosinnusManagedTagManager(models.Manager):
# a list of all CosinnusManagedTags
_MANAGED_TAG_ALL_LIST_CACHE_KEY = 'cosinnus/core/portal/%d/managed_tags/all' # portal_id
# a dict of *both* mappings from int and slug to CosinnusManagedTags. contains duplicate tags!
_MANAGED_TAG_DICT_CACHE_KEY = 'cosinnus/core/portal/%d/managed_tags/dict' # portal_id
def all_in_portal(self):
""" Returns all managed tags within the current portal only """
return self.get_queryset().filter(
portal=CosinnusPortal().get_current())
def all_in_portal_cached(self):
def send_payment_event_payment_email(payment, event):
""" Sends an email to a user for an event such ass success/errors in payments, or updates to subscriptions.
Mail type depends on the given event.
@param payment: Always supply a payment for this function, the subscription will be taken from its
`subscription` relation. If all you have is a subscription, supply the `subscription.last_payment`.
@param event: one of the values of `PAYMENT_EVENTS`.
@return: True if the mail was successfully relayed, False or raises otherwise.
"""
cur_language = translation.get_language()
try:
if not payment.user:
logger.warning(
'Sending payment status message was ignored because no user was attached to the payment',
extra={'payment': payment.id})
return
if not event in PAYMENT_EVENTS:
logger.error(
'Could not send out a payment event email because the event type was unknown.',
extra={'payment': payment.id})
return
user = payment.user
email = user.email
template = 'wechange_payments/mail/mail_base.html'
subject_template = 'wechange_payments/mail/subject_base.txt'
portal = CosinnusPortal.get_current()
# switch language to user's preference language
translation.activate(
getattr(user.cosinnus_profile, 'language',
settings.LANGUAGES[0][0]))
link_html = '[' + str(pgettext_lazy(
'(URL-LABEL)', 'Link')) + '](' + portal.get_domain() + '%s)'
mail_html = '[%s](mailto:%s)'
# prepare all possible variables
sepa_mandate = None
iban = None
if payment.type == PAYMENT_TYPE_DIRECT_DEBIT:
reference_payment = payment.subscription.reference_payment
sepa_mandate = reference_payment.extra_data.get(
'sepa_mandate_token', None)
iban = reference_payment.extra_data.get('iban', None)
variables = {
'payment':
payment,
'link_payment_info':
link_html % reverse('wechange_payments:payment-infos'),
'link_invoices':
link_html % reverse('wechange_payments:invoices'),
'link_new_payment':
link_html % reverse('wechange_payments:payment'),
'link_payment_issues':
link_html % reverse('wechange_payments:suspended-subscription'),
'portal_name':
portal.name,
'username':
full_name(payment.user),
'payment_amount':
str(int(payment.amount)),
'vat_amount':
str(int(settings.PAYMENTS_INVOICE_PROVIDER_TAX_RATE_PERCENT)),
'subscription_amount':
str(int(payment.subscription.amount)),
'next_debit_date':
localize(payment.subscription.get_next_payment_date()),
'payment_method':
payment.get_type_string(),
'support_email':
mail_html % (portal.support_email, portal.support_email),
'sepa_mandate':
sepa_mandate,
'iban':
iban,
'sepa_creditor':
settings.PAYMENTS_SEPA_CREDITOR_ID,
}
# compose email parts
data = {
'mail_pre': MAIL_PRE % variables,
'mail_links': MAIL_LINKS % variables,
'mail_post': MAIL_POST % variables,
'mail_body': MAIL_BODY.get(event) % variables,
'mail_subject': MAIL_SUBJECT.get(event) % variables,
}
# add SEPA mandate info to mail body for successful SEPA payment email
if payment.type == PAYMENT_TYPE_DIRECT_DEBIT and event == PAYMENT_EVENT_SUCCESSFUL_PAYMENT:
sepa_variables = {
'payment': payment.subscription.reference_payment,
'SETTINGS': settings,
}
data['mail_body'] += '\n\n-\n\n' + render_to_string(
'wechange_payments/mail/sepa_mandate_partial.html',
sepa_variables)
# send mail
if settings.PAYMENTS_USE_HOOK_INSTEAD_OF_SEND_MAIL == True:
signals.success_email_sender.send(
sender=payment,
to_user=user,
template=template,
subject_template=subject_template,
data=data)
else:
subject = render_to_string(subject_template, data)
message = render_to_string(template, data)
mail_func = resolve_class(settings.PAYMENTS_SEND_MAIL_FUNCTION)
mail_func(subject, message, settings.DEFAULT_FROM_EMAIL, [email])
return True
except Exception as e:
logger.warning(
'Payments: Sending a payment status email to the user failed!',
extra={
'internal_transaction_id': payment.internal_transaction_id,
'vendor_transaction_id': payment.vendor_transaction_id,
'exception': e
})
if settings.DEBUG:
raise
return False
# switch language back to previous
translation.activate(cur_language)