def waitinglist(request):
renderdict = get_menu_dict(request)
waitinglist = SubscriptionDao.not_started_subscriptions()
renderdict.update({
'waitinglist': waitinglist
})
return render(request, 'waitinglist.html', renderdict)
def filter_subscriptions_depot(request, depot_id):
now = timezone.now()
subscriptions = []
depot = get_object_or_404(Depot, id=int(depot_id))
for subscription in SubscriptionDao.subscritions_by_depot(depot):
assignments = 0
core_assignments = 0
for member in MemberDao.members_with_assignments_count_in_subscription(subscription):
assignments += member.assignment_count if member.assignment_count is not None else 0
core_assignments += member.core_assignment_count if member.core_assignment_count is not None else 0
subscriptions.append({
'subscription': subscription,
'text': get_status_image_text(100 / (subscription.size * 10) * assignments if subscription.size > 0 else 0),
'assignments': assignments,
'core_assignments': core_assignments,
'icon': get_status_image(
100 / (subscription.size * 10) * assignments if subscription.size > 0 else 0)
})
renderdict = get_menu_dict(request)
renderdict.update({
'subscriptions': subscriptions
})
return render(request, 'subscriptions.html', renderdict)
def maps(request):
renderdict = {
'depots': DepotDao.all_depots(),
'subscriptions': SubscriptionDao.all_active_subscritions(),
}
return render(request, 'maps.html', renderdict)
def maps(request):
renderdict = {
"depots": DepotDao.all_depots(),
"subscriptions": SubscriptionDao.all_active_subscritions(),
}
return render(request, "maps.html", renderdict)
def subscriptions(request):
now = timezone.now()
subscriptions = []
for subscription in SubscriptionDao.all_subscritions():
assignments = 0
core_assignments = 0
for member in MemberDao.members_with_assignments_count_in_subscription(subscription):
assignments += member.assignment_count
core_assignments += member.core_assignment_count
subscriptions.append({
'subscription': subscription,
'text': get_status_image_text(100 / (subscription.size * 10) * assignments if subscription.size > 0 else 0),
'assignments': assignments,
'core_assignments': core_assignments,
'icon': get_status_image(
100 / (subscription.size * 10) * assignments if subscription.size > 0 else 0)
})
renderdict = get_menu_dict(request)
renderdict.update({
'subscriptions': subscriptions
})
return render(request, 'subscriptions.html', renderdict)
def sub_inconsistencies(request):
management_list = []
for sub in SubscriptionDao.all_subscritions():
try:
sub.clean()
for part in sub.parts.all():
part.clean()
for member in sub.subscriptionmembership_set.all():
member.clean()
except Exception as e:
management_list.append({'subscription': sub, 'error': e})
if sub.primary_member is None:
management_list.append({
'subscription':
sub,
'error':
_('Haubtbezieher ist nicht gesetzt')
})
render_dict = get_menu_dict(request)
render_dict.update({
'change_date_disabled': True,
'email_form_disabled': True
})
return subscription_management_list(management_list, render_dict,
'management_lists/inconsistent.html',
request)
def excel_export_subscriptions(request):
response = HttpResponse(content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
response['Content-Disposition'] = 'attachment; filename=Report.xlsx'
output = BytesIO()
workbook = Workbook(output)
worksheet_s = workbook.add_worksheet(Config.vocabulary('subscription_pl'))
worksheet_s.write_string(0, 0, str(_('Übersicht')))
worksheet_s.write_string(0, 1, str(_('HauptbezieherIn')))
worksheet_s.write_string(0, 2, str(_('HauptbezieherInEmail')))
worksheet_s.write_string(0, 3, str(_('HauptbezieherInTelefon')))
worksheet_s.write_string(0, 4, str(_('HauptbezieherInMobile')))
worksheet_s.write_string(0, 5, str(_('Weitere BezieherInnen')))
worksheet_s.write_string(0, 6, str(_('Status')))
worksheet_s.write_string(0, 7, str(_('Depot')))
worksheet_s.write_string(0, 8, str(Config.vocabulary('assignment')))
worksheet_s.write_string(0, 9, str(_('{} soll'.format(Config.vocabulary('assignment')))))
worksheet_s.write_string(0, 10, str(_('{} status(%)'.format(Config.vocabulary('assignment')))))
worksheet_s.write_string(0, 11, str(_('{} Kernbereich'.format(Config.vocabulary('assignment')))))
worksheet_s.write_string(0, 12, str(_('{} Kernbereich soll'.format(Config.vocabulary('assignment')))))
worksheet_s.write_string(0, 13, str(_('{} Kernbereich status(%)'.format(Config.vocabulary('assignment')))))
worksheet_s.write_string(0, 14, str(_('Preis')))
subs = subscriptions_with_assignments(SubscriptionDao.all_subscritions())
row = 1
for sub in subs:
primary_member = sub['subscription'].primary_member
if primary_member is not None:
name = primary_member.get_name()
email = primary_member.email
phone = primary_member.phone or ''
mobile = primary_member.mobile_phone or ''
else:
name = ''
email = ''
phone = ''
mobile = ''
worksheet_s.write_string(row, 0, sub['subscription'].overview)
worksheet_s.write_string(row, 1, name)
worksheet_s.write_string(row, 2, email)
worksheet_s.write_string(row, 3, phone)
worksheet_s.write_string(row, 4, mobile)
worksheet_s.write_string(row, 5, sub['subscription'].other_recipients_names)
worksheet_s.write_string(row, 6, sub['subscription'].state_text)
worksheet_s.write_string(row, 7, sub['subscription'].depot.name)
worksheet_s.write(row, 8, sub.get('assignments'))
worksheet_s.write(row, 9, sub['subscription'].required_assignments)
worksheet_s.write(row, 10, sub.get('assignments_progress'))
worksheet_s.write(row, 11, sub.get('core_assignments'))
worksheet_s.write(row, 12, sub['subscription'].required_core_assignments)
worksheet_s.write(row, 13, sub.get('core_assignments_progress'))
worksheet_s.write(row, 14, sub['subscription'].price)
row += 1
workbook.close()
xlsx_data = output.getvalue()
response.write(xlsx_data)
return response
def typechangelist(request):
changedlist = []
subscriptions = SubscriptionDao.all_active_subscritions()
for subscription in subscriptions:
if subscription.types_changed:
changedlist.append(subscription)
return subscription_management_list(changedlist, get_menu_dict(request), 'typechangelist.html', request)
def assignments(request):
management_list = subscriptions_with_assignments(
SubscriptionDao.all_active_subscritions())
render_dict = get_menu_dict(request)
render_dict.update({'change_date_disabled': True})
return subscription_management_list(management_list, render_dict,
'management_lists/assignments.html',
request)
def subscriptions(request):
renderdict = get_menu_dict(request)
renderdict.update({
'subscriptions': SubscriptionDao.all_active_subscritions(),
'title': _('Alle aktiven {} im Überblick').format(Config.vocabulary('subscription_pl'))
})
return render(request, 'subscriptions.html', renderdict)
def get_available_subscriptions():
goal = int(getattr(settings, "SUBSCRIPTION_PROGRESS_GOAL", "10") or "10")
target = SubscriptionPart.objects.filter(
~q_cancelled() & ~q_deactivated(),
type__size__product__is_extra=False,
subscription__in=SubscriptionDao.future_subscriptions()).aggregate(
total=Sum('type__size__units'))['total']
return goal - target
def subscriptions(request):
subscriptions_list = subscriptions_with_assignments(
SubscriptionDao.all_active_subscritions())
renderdict = get_menu_dict(request)
renderdict.update({'subscriptions': subscriptions_list})
return render(request, 'subscriptions.html', renderdict)
def handle(self, *args, **options):
if not options['force'] and timezone.now().weekday(
) not in Config.depot_list_generation_days():
print(
'not the specified day for depot list generation, use --force to override'
)
return
if options['future'] or timezone.now().weekday(
) in Config.depot_list_generation_days():
for subscription in SubscriptionDao.subscritions_with_future_depots(
):
subscription.depot = subscription.future_depot
subscription.future_depot = None
subscription.save()
emails = []
for member in subscription.recipients:
emails.append(member.email)
membernotification.depot_changed(emails, subscription.depot)
if options['force'] and not options['future']:
print('future depots ignored, use --future to override')
depot_dict = {
'subscriptions':
SubscriptionDao.all_active_subscritions(),
'products':
SubscriptionProductDao.get_all_for_depot_list(),
'extra_sub_categories':
ExtraSubscriptionCategoryDao.categories_for_depot_list_ordered(),
'depots':
DepotDao.all_depots_order_by_code(),
'weekdays': {
weekdays[weekday['weekday']]: weekday['weekday']
for weekday in DepotDao.distinct_weekdays()
},
'messages':
ListMessageDao.all_active()
}
render_to_pdf_storage('exports/depotlist.html', depot_dict,
'depotlist.pdf')
render_to_pdf_storage('exports/depot_overview.html', depot_dict,
'depot_overview.pdf')
render_to_pdf_storage('exports/amount_overview.html', depot_dict,
'amount_overview.pdf')
def filter_subscriptions_depot(request, depot_id):
depot = get_object_or_404(Depot, id=int(depot_id))
subscriptions_list = subscriptions_with_assignments(
SubscriptionDao.active_subscritions_by_depot(depot))
renderdict = get_menu_dict(request)
renderdict.update({'subscriptions': subscriptions_list})
return render(request, 'subscriptions.html', renderdict)
def activate_future_depots():
for subscription in SubscriptionDao.subscritions_with_future_depots():
subscription.depot = subscription.future_depot
subscription.future_depot = None
subscription.save()
emails = []
for member in subscription.recipients:
emails.append(member.email)
membernotification.depot_changed(emails, subscription.depot)
def typechangelist(request):
render_dict = get_menu_dict(request)
render_dict.update(get_changedate(request))
changedlist = []
subscriptions_list = SubscriptionDao.all_active_subscritions().filter(~q_cancelled())
for subscription in subscriptions_list:
if subscription.types_changed > 0:
changedlist.append(subscription)
return subscription_management_list(changedlist, render_dict, 'management_lists/typechangelist.html', request)
def list_content_changes(request, subscription_id=None):
render_dict = get_changedate(request)
changedlist = []
subscriptions_list = SubscriptionDao.all_active_subscritions()
for subscription in subscriptions_list:
if subscription.content.content_changed:
changedlist.append(subscription)
return subscription_management_list(changedlist, render_dict,
"cs/list_content_changes.html",
request)
def handle(self, *args, **options):
now = timezone.now()
periods = ExtraSubBillingPeriodDao.get_starting_for_date(now)
for period in periods:
for extra in period.type.extra_subscriptions.filter(active=True):
bill_extra_subscription(extra, period)
bs = Config.business_year_start()
if now.day == bs['day'] and now.month == bs['month']:
for subscription in SubscriptionDao.all_active_subscritions():
bill_subscription(subscrtption)
def future(request):
renderdict = get_menu_dict(request)
subscriptionsizes = []
subscription_lines = dict({})
extra_lines = dict({})
for subscription_size in SubscriptionSizeDao.all_sizes_ordered():
subscriptionsizes.append(subscription_size.id)
subscription_lines[subscription_size.id] = {
'name':
subscription_size.product.name + '-' + subscription_size.name,
'future': 0,
'now': 0
}
for extra_subscription in ExtraSubscriptionTypeDao.all_extra_types():
extra_lines[extra_subscription.name] = {
'name': extra_subscription.name,
'future': 0,
'now': 0
}
for subscription in SubscriptionDao.all_active_subscritions():
for subscription_size in subscriptionsizes:
subscription_lines[subscription_size][
'now'] += subscription.subscription_amount(subscription_size)
for users_subscription in ExtraSubscriptionDao.all_active_extrasubscritions(
):
extra_lines[users_subscription.type.name]['now'] += 1
for subscription in SubscriptionDao.future_subscriptions():
for subscription_size in subscriptionsizes:
subscription_lines[subscription_size][
'future'] += subscription.subscription_amount_future(
subscription_size)
for users_subscription in ExtraSubscriptionDao.future_extrasubscriptions():
extra_lines[users_subscription.type.name]['future'] += 1
renderdict.update({
'changed': request.GET.get('changed'),
'subscription_lines': iter(subscription_lines.values()),
'extra_lines': iter(extra_lines.values()),
})
return render(request, 'future.html', renderdict)
def generate_pdf_dict():
return {
'subscriptions': SubscriptionDao.all_active_subscritions(),
'products': SubscriptionProductDao.get_all(),
'depots': DepotDao.all_depots_order_by_code(),
'weekdays': {
weekdays[weekday['weekday']]: weekday['weekday']
for weekday in DepotDao.distinct_weekdays()
},
'messages': ListMessageDao.all_active()
}
def filter_subscriptions_depot(request, depot_id):
depot = get_object_or_404(Depot, id=int(depot_id))
renderdict = get_menu_dict(request)
renderdict['can_send_mails'] = True
renderdict.update({
'subscriptions': SubscriptionDao.active_subscritions_by_depot(depot),
'mail_url': 'mail-depot',
'title': _('Alle aktiven {} im {} {}').format(Config.vocabulary('subscription_pl'), Config.vocabulary('depot'), depot.name)
})
return render(request, 'subscriptions.html', renderdict)
def change_extras(request):
for subscription in SubscriptionDao.all_subscritions():
for extra in subscription.extra_subscription_set.all():
if extra.active is True and extra.canceled is True:
extra.active = False
extra.save()
elif extra.active is False and extra.deactivation_date is None:
extra.active = True
extra.save()
return redirect('/my/future?changed=true')
def depot_change_overview(request):
renderdict = {
'menu': {
'dm': 'active'
},
'change_date_disabled': True,
}
changedlist = []
changedlist = SubscriptionDao.subscritions_with_future_depots()
return subscription_management_list(changedlist, renderdict,
"dm/depot_change_overview.html",
request)
def change_subscriptions(request):
renderdict = get_menu_dict(request)
for subscription in SubscriptionDao.all_subscritions():
if subscription.size is not subscription.future_size:
if subscription.future_size is 0:
subscription.active = False
if subscription.size is 0:
subscription.active = True
subscription.size = subscription.future_size
subscription.save()
renderdict.update({
})
return redirect('/my/future?changed=true')
def indexes(request):
active_parts = SubscriptionPart.objects.filter(
type__size__product__is_extra=False).filter(q_isactive()).filter(
subscription__in=SubscriptionDao().all_active_subscritions())
types = SubscriptionTypeDao.get_all().filter(
subscription_parts__in=active_parts).annotate(
num=Count('id')).order_by('-price')
renderdict = dict(
subscription_types=types,
average_sub_price=active_parts.aggregate(
avg=Avg('type__price'))['avg'],
average_paid_sub_price=active_parts.filter(
type__price__gt=0).aggregate(avg=Avg('type__price'))['avg'],
)
return render(request, 'mag/stats/indexes.html', renderdict)
def assignments_by_subscription(start_date, end_date, activty_area=None):
subscriptions_list = []
for subscription in SubscriptionDao.all_active_subscritions().annotate(
totalsize=Sum('types__size__units')):
assignments = 0
for member in members_with_assignments(start_date,
end_date,
activty_area,
members=subscription.members):
if member.assignments:
assignments += member.assignments
subscriptions_list.append({
'subscription': subscription,
'assignments': assignments,
})
return subscriptions_list
def excel_export_subscriptions(request):
filename = '{}_{}.xlsx'.format(Config.vocabulary('subscription_pl'),
timezone.now().date())
response = HttpResponse(
content_type=
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
response['Content-Disposition'] = 'attachment; filename=' + filename
wb = Workbook()
# Sheet 1: Subscriptions with prices
ws1 = wb.active
ws1.title = Config.vocabulary('subscription_pl')
# header
ws1.cell(1, 1, u"{}".format(Config.vocabulary('member_pl')))
ws1.column_dimensions['A'].width = 40
ws1.cell(1, 2, u"{}".format(_('E-Mail')))
ws1.column_dimensions['B'].width = 30
ws1.cell(1, 3,
u"{}".format(_('Gesamtpreis [{}]').format(Config.currency())))
ws1.column_dimensions['C'].width = 17
for column, subs_type in enumerate(SubscriptionTypeDao.get_all(), 4):
ws1.cell(1, column, u"EAT {}".format(subs_type.price))
ws1.column_dimensions[get_column_letter(column)].width = 17
# data
for row, subscription in enumerate(
SubscriptionDao.all_active_subscritions(), 2):
ws1.cell(
row, 1, ", ".join(
[member.get_name() for member in subscription.recipients]))
ws1.cell(row, 2, subscription.primary_member.email)
ws1.cell(row, 3, subscription.price)
for column, subs_type in enumerate(SubscriptionTypeDao.get_all(), 4):
ws1.cell(
row, column,
subscription.active_parts.filter(
type__id=subs_type.id).count())
ws1.freeze_panes = ws1['A2']
wb.save(response)
return response
def depot_overview_direct(request):
depot_dict = {
'subscriptions':
SubscriptionDao.all_active_subscritions(),
'products':
SubscriptionProductDao.get_all_for_depot_list(),
'extra_sub_categories':
ExtraSubscriptionCategoryDao.categories_for_depot_list_ordered(),
'depots':
DepotDao.all_depots_order_by_code(),
'weekdays': {
weekdays[weekday['weekday']]: weekday['weekday']
for weekday in DepotDao.distinct_weekdays()
},
'messages':
ListMessageDao.all_active()
}
return render_to_pdf_http('exports/depot_overview.html', depot_dict,
'depotlist.pdf')
def subscriptions(request):
subscriptions_list = []
for subscription in SubscriptionDao.all_subscritions():
assignments = 0
core_assignments = 0
for member in MemberDao.members_with_assignments_count_in_subscription(
subscription):
assignments += member.assignment_count if member.assignment_count is not None else 0
core_assignments += member.core_assignment_count if member.core_assignment_count is not None else 0
subscriptions_list.append({
'subscription': subscription,
'assignments': assignments,
'core_assignments': core_assignments
})
renderdict = get_menu_dict(request)
renderdict.update({'subscriptions': subscriptions_list})
return render(request, 'subscriptions.html', renderdict)
def filter_subscriptions_depot(request, depot_id):
subscriptions_list = []
depot = get_object_or_404(Depot, id=int(depot_id))
for subscription in SubscriptionDao.subscritions_by_depot(depot):
assignments = 0
core_assignments = 0
for member in MemberDao.members_with_assignments_count_in_subscription(
subscription):
assignments += member.assignment_count if member.assignment_count is not None else 0
core_assignments += member.core_assignment_count if member.core_assignment_count is not None else 0
subscriptions_list.append({
'subscription': subscription,
'assignments': assignments,
'core_assignments': core_assignments
})
renderdict = get_menu_dict(request)
renderdict.update({'subscriptions': subscriptions_list})
return render(request, 'subscriptions.html', renderdict)
