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 cs_select_depot(request, cs_session):
if request.method == 'POST':
cs_session.depot = DepotDao.depot_by_id(request.POST.get('depot'))
return redirect(cs_session.next_page())
depots = DepotDao.all_depots()
requires_map = any(depot.has_geo for depot in depots)
render_dict = {
'member': cs_session.main_member,
'depots': depots,
'selected': cs_session.depot,
'requires_map': requires_map,
}
return render(request, 'createsubscription/select_depot.html', render_dict)
def depot_change(request, subscription_id):
'''
change a depot
'''
subscription = get_object_or_404(Subscription, id=subscription_id)
saved = False
if request.method == 'POST':
if subscription.state == 'waiting':
subscription.depot = get_object_or_404(
Depot, id=int(request.POST.get('depot')))
else:
subscription.future_depot = get_object_or_404(
Depot, id=int(request.POST.get('depot')))
subscription.save()
saved = True
renderdict = get_menu_dict(request)
depots = DepotDao.all_depots()
requires_map = False
for depot in depots:
requires_map = requires_map or depot.has_geo
renderdict.update({
'subscription': subscription,
'saved': saved,
'member': request.user.member,
'depots': depots,
'requires_map': requires_map,
})
return render(request, 'depot_change.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 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 get_menu_dict(request):
member = request.user.member
next_jobs = [a.job for a in AssignmentDao.upcomming_assignments_for_member(member).order_by('job__time')]
required_assignments = 0
if member.subscription is not None:
partner_assignments = []
for subscription_member in member.subscription.recipients_all:
if subscription_member == member:
continue
partner_assignments.extend(
AssignmentDao.assignments_for_member_current_business_year(subscription_member))
userassignments = AssignmentDao.assignments_for_member_current_business_year(
member)
required_assignments = member.subscription.required_assignments
else:
partner_assignments = []
userassignments = []
userassignments_total = int(sum(a.amount for a in userassignments))
userassignemnts_core = int(
sum(a.amount for a in userassignments if a.is_core()))
partner_assignments_total = int(sum(a.amount for a in partner_assignments))
partner_assignments_core = int(
sum(a.amount for a in partner_assignments if a.is_core()))
assignmentsrange = list(range(
0, max(required_assignments, userassignments_total+partner_assignments_total)))
depot_admin = DepotDao.depots_for_contact(request.user.member)
area_admin = ActivityAreaDao.areas_by_coordinator(request.user.member)
menu_dict = get_page_dict(request)
menu_dict.update({
'user': request.user,
'assignmentsrange': assignmentsrange,
'userassignments_bound': userassignments_total,
'userassignemnts_core_bound': userassignemnts_core,
'partner_assignments_bound': userassignments_total + partner_assignments_total,
'partner_assignments_core_bound': userassignments_total + partner_assignments_core,
'next_jobs': next_jobs,
'can_filter_members': request.user.has_perm('juntagrico.can_filter_members'),
'can_filter_subscriptions': request.user.has_perm('juntagrico.can_filter_subscriptions'),
'can_send_mails': request.user.has_perm('juntagrico.can_send_mails'),
'operation_group': request.user.has_perm('juntagrico.is_operations_group'),
'has_extra_subscriptions': ExtraSubscriptionCategoryDao.all_categories_ordered().count() > 0,
'depot_admin': depot_admin,
'area_admin': area_admin,
'show_core': ActivityAreaDao.all_core_areas().count() > 0,
'show_extras': JobExtraDao.all_job_extras().count() > 0,
'show_deliveries': len(DeliveryDao.deliveries_by_subscription(request.user.member.subscription)) > 0,
'admin_menus': addons.config.get_admin_menus(),
'user_menus': addons.config.get_user_menus(),
'messages': [],
})
return menu_dict
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 cs_select_depot(request):
if request.user.is_authenticated:
member = request.user.member
else:
member = request.session.get('main_member')
if member is None:
return redirect('http://' + Config.server_url())
if request.method == 'POST':
depot = DepotDao.depot_by_id(request.POST.get('depot'))
request.session['selecteddepot'] = depot
return redirect('/my/create/subscription/start')
depots = DepotDao.all_depots()
requires_map = True
for depot in depots:
requires_map = requires_map or depot.has_geo
renderdict = {
'member': member,
'depots': depots,
'requires_map': requires_map,
}
return render(request, 'createsubscription/select_depot.html', renderdict)
def depot_change(request):
"""
change a depot
"""
saved = False
if request.method == "POST":
request.user.member.subscription.future_depot = get_object_or_404(
Depot, id=int(request.POST.get("depot")))
request.user.member.subscription.save()
saved = True
renderdict = get_menu_dict(request)
renderdict.update({
'saved': saved,
'member': request.user.member,
"depots": DepotDao.all_depots()
})
return render(request, "depot_change.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)
send_depot_changed(emails, subscription.depot)
if options['force'] and not options['future']:
print('future depots ignored, use --future to override')
depots = DepotDao.all_depots_order_by_code()
subscription_names = []
for subscription_size in SubscriptionSizeDao.sizes_for_depot_list():
subscription_names.append(subscription_size.name)
categories = []
types = []
for category in ExtraSubscriptionCategoryDao.all_categories_ordered():
cat = {'name': category.name, 'description': category.description}
count = 0
for extra_subscription in ExtraSubscriptionTypeDao.extra_types_by_category_ordered(
category):
count += 1
type = {
'name': extra_subscription.name,
'size': extra_subscription.size,
'last': False
}
types.append(type)
type['last'] = True
cat['count'] = count
categories.append(cat)
used_weekdays = []
for item in DepotDao.distinct_weekdays():
used_weekdays.append(weekdays[item['weekday']])
overview = {'all': None}
for weekday in used_weekdays:
overview[weekday] = None
count = len(types) + len(subscription_names)
for weekday in used_weekdays:
overview[weekday] = [0] * count
overview['all'] = [0] * count
all = overview.get('all')
for depot in depots:
depot.fill_overview_cache()
depot.fill_active_subscription_cache()
row = overview.get(depot.get_weekday_display())
count = 0
# noinspection PyTypeChecker
while count < len(row):
row[count] += depot.overview_cache[count]
all[count] += depot.overview_cache[count]
count += 1
insert_point = len(subscription_names)
for weekday in used_weekdays:
overview[weekday].insert(insert_point, 0)
overview['all'].insert(insert_point, 0)
index = 0
for subscription_size in SubscriptionSizeDao.sizes_for_depot_list():
for weekday in used_weekdays:
overview[weekday][insert_point] = overview[weekday][insert_point] + subscription_size.size * \
overview[weekday][index]
overview['all'][insert_point] = overview['all'][
insert_point] + subscription_size.size * overview['all'][index]
index += 1
renderdict = {
'overview': overview,
'depots': depots,
'subscription_names': subscription_names,
'subscriptioncount': len(subscription_names) + 1,
'categories': categories,
'types': types,
'datum': timezone.now(),
'weekdays': used_weekdays
}
render_to_pdf_storage('exports/legacy.html', renderdict, 'dpl.pdf')
render_to_pdf_storage('exports/depotlist.html', renderdict,
'depotlist.pdf')
render_to_pdf_storage('exports/depot_overview.html', renderdict,
'depot_overview.pdf')
render_to_pdf_storage('exports/amount_overview.html', renderdict,
'amount_overview.pdf')
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():
activate_future_depots()
if options['force'] and not options['future']:
print('future depots ignored, use --future to override')
products = [{
'name': 'Gemüse',
'sizes': [{
'name': 'Tasche',
'key': 'gmues'
}]
}, {
'name': 'Obst',
'sizes': [{
'name': 'Portion',
'key': 'obst'
}]
}, {
'name': 'Brot',
'sizes': [{
'name': '500g',
'key': 'brot'
}]
}, {
'name': 'Eier',
'sizes': [{
'name': '4er',
'key': 'eier'
}]
}, {
'name': 'Tofu',
'sizes': [{
'name': 'Portion',
'key': 'tofu'
}]
}]
gmues_types = SubscriptionType.objects.filter(
pk__in=[6, 7, 8, 9, 10, 11, 12, 13, 18])
obst_types = SubscriptionType.objects.filter(pk__in=[
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22
])
brot_types = SubscriptionType.objects.filter(
pk__in=[8, 9, 12, 13, 16, 17, 19, 20])
tofu_types = ExtraSubscriptionType.objects.filter(pk__in=[11])
eier_types = ExtraSubscriptionType.objects.filter(pk__in=[1])
now = dateformat.format(timezone.now(), 'Y-m-d')
subs = SubscriptionDao.all_active_subscritions(). \
annotate(gmues=Count('parts',
filter=Q(parts__type__in=gmues_types) & Q(
parts__activation_date__lte=now) & (Q(
parts__deactivation_date__isnull=True) | Q(parts__deactivation_date__gte=now)),
distinct=True)). \
annotate(obst=Count('parts',
filter=Q(parts__type__in=obst_types) & Q(parts__activation_date__lte=now) & (Q(
parts__deactivation_date__isnull=True) | Q(parts__deactivation_date__gte=now)),
distinct=True)). \
annotate(brot=Count('parts',
filter=Q(parts__type__in=brot_types) & Q(parts__activation_date__lte=now) & (Q(
parts__deactivation_date__isnull=True) | Q(
parts__deactivation_date__gte=now)), distinct=True)). \
annotate(tofu=Count('extra_subscription_set', filter=Q(extra_subscription_set__type__in=tofu_types) & Q(
extra_subscription_set__activation_date__lte=now) & (Q(
extra_subscription_set__deactivation_date__isnull=True) | Q(
extra_subscription_set__deactivation_date__gte=now)), distinct=True)). \
annotate(eier=Count('extra_subscription_set', filter=Q(extra_subscription_set__type__in=eier_types) & Q(
extra_subscription_set__activation_date__lte=now) & (Q(
extra_subscription_set__deactivation_date__isnull=True) | Q(
extra_subscription_set__deactivation_date__gte=now)), distinct=True))
depots = DepotDao.all_depots_order_by_code().prefetch_related('subscription_set'). \
annotate(
gmues=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=gmues_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(
obst=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=obst_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(
brot=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=brot_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(tofu=Count('subscription_set__extra_subscription_set',
filter=Q(subscription_set__extra_subscription_set__type__in=tofu_types) & Q(
subscription_set__extra_subscription_set__activation_date__lte=now) & (Q(
subscription_set__extra_subscription_set__deactivation_date__isnull=True) | Q(
subscription_set__extra_subscription_set__deactivation_date__gte=now)),
distinct=True)). \
annotate(eier=Count('subscription_set__extra_subscription_set',
filter=Q(subscription_set__extra_subscription_set__type__in=eier_types) & Q(
subscription_set__extra_subscription_set__activation_date__lte=now) & (Q(
subscription_set__extra_subscription_set__deactivation_date__isnull=True) | Q(
subscription_set__extra_subscription_set__deactivation_date__gte=now)),
distinct=True))
days = Depot.objects.all().prefetch_related('subscription_set'). \
values('weekday').order_by('weekday'). \
annotate(
gmues=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=gmues_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(
obst=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=obst_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(
brot=Count('subscription_set__parts', filter=Q(subscription_set__parts__type__in=brot_types) & Q(
subscription_set__parts__activation_date__lte=now) & (Q(
subscription_set__parts__deactivation_date__isnull=True) | Q(
subscription_set__parts__deactivation_date__gte=now)), distinct=True)). \
annotate(tofu=Count('subscription_set__extra_subscription_set',
filter=Q(subscription_set__extra_subscription_set__type__in=tofu_types) & Q(
subscription_set__extra_subscription_set__activation_date__lte=now) & (Q(
subscription_set__extra_subscription_set__deactivation_date__isnull=True) | Q(
subscription_set__extra_subscription_set__deactivation_date__gte=now)),
distinct=True)). \
annotate(eier=Count('subscription_set__extra_subscription_set',
filter=Q(subscription_set__extra_subscription_set__type__in=eier_types) & Q(
subscription_set__extra_subscription_set__activation_date__lte=now) & (Q(
subscription_set__extra_subscription_set__deactivation_date__isnull=True) | Q(
subscription_set__extra_subscription_set__deactivation_date__gte=now)),
distinct=True))
for day in days:
day['name'] = weekdays[day['weekday']]
for product in products:
for size in product['sizes']:
total = 0
for day in days:
total += day[size['key']]
size['total'] = total
depot_dict = {
'weekdays': days,
'depots': depots,
'products': products,
'subscriptions': subs,
'messages': ListMessageDao.all_active(),
}
render_to_pdf_storage('exports_oooo/depotlist.html', depot_dict,
'depotlist.pdf')
render_to_pdf_storage('exports_oooo/depot_overview.html', depot_dict,
'depot_overview.pdf')
render_to_pdf_storage('exports_oooo/amount_overview.html', depot_dict,
'amount_overview.pdf')
# cleanup files from preview runs
legacy_files = [
'depotlist_pre.pdf', 'depot_overview_pre.pdf',
'amount_overview_pre.pdf'
]
for file in legacy_files:
if default_storage.exists(file):
default_storage.delete(file)
def add_member(request, subscription_id):
shareerror = False
shares = 1
memberexists = False
memberblocked = False
if request.method == 'POST':
memberform = MemberProfileForm(request.POST)
try:
shares = int(request.POST.get("shares"))
shareerror = shares < 0
except:
shareerror = True
member = next(
iter(MemberDao.members_by_email(request.POST.get('email')) or []),
None)
if member is not None:
memberexists = True
shares = 0
if member.subscription is not None:
memberblocked = True
if (memberform.is_valid()
and shareerror is False) or (memberexists is True
and memberblocked is False):
tmp_shares = []
pw = None
if memberexists is False:
for num in range(0, shares):
member = Member(**memberform.cleaned_data)
tmp_shares.append(Share(member=member, paid_date=None))
else:
for share in member.share_set.all():
tmp_shares.append(share)
if request.GET.get("return"):
member.subscription_id = subscription_id
member.save()
send_been_added_to_subscription(
member.email, pw, request.user.member.get_name(), shares,
hashlib.sha1(memberform.cleaned_data['email'] +
str(subscription_id)).hexdigest())
if memberexists is False:
for share in tmp_shares:
share.save()
send_share_created_mail(share)
return redirect(request.GET.get("return"))
else:
co_members_shares = request.session.get(
'create_co_members_shares', [])
co_members_shares += tmp_shares
request.session['create_co_members_shares'] = co_members_shares
co_members = request.session.get('create_co_members', [])
co_members.append(member)
request.session['create_co_members'] = co_members
return redirect('/my/create/subscrition')
else:
if request.user.is_authenticated():
member = request.user.member
else:
member = request.session.get('main_member')
if member is None:
return redirect("http://" + Config.server_url())
initial = {
"addr_street": member.addr_street,
"addr_zipcode": member.addr_zipcode,
"addr_location": member.addr_location,
"phone": member.phone,
}
memberform = MemberProfileForm(initial=initial)
renderdict = {
'shares':
shares,
'memberexists':
memberexists,
'memberblocked':
memberexists,
'shareerror':
shareerror,
'memberform':
memberform,
"member":
member,
"depots":
DepotDao.all_depots(),
"cancelUrl":
request.GET.get("return")
if request.GET.get("return") else '/my/create/subscrition'
}
return render(request, "add_member.html", renderdict)
def createsubscription(request):
"""
create a subscription
"""
if request.user.is_authenticated():
member = request.user.member
else:
member = request.session.get('main_member')
if member is None:
return redirect("http://" + Config.server_url())
shareerror = False
subscriptionform = SubscriptionForm()
session_subscription = request.session.get('create_subscription')
co_members = request.session.get('create_co_members', [])
co_members_shares = request.session.get('create_co_members_shares', [])
member_shares = request.session.get('create_member_shares', [])
selectedsubscription = "none"
selected_depot = None
existing_member_shares = 0
if member.pk is not None:
existing_member_shares = member.share_set.all().count()
shares = existing_member_shares
if session_subscription is not None:
selectedsubscription = next(
iter(
SubscriptionSizeDao.sizes_by_size(
session_subscription.size).values_list('name', flat=True)
or []), 'none')
selected_depot = session_subscription.depot
co_member_shares = len(co_members_shares)
if request.method == "POST":
shares += int(request.POST.get("shares"))
selectedsubscription = request.POST.get("subscription")
subscriptionform = SubscriptionForm(request.POST)
shares += co_member_shares
min_num_shares = next(
iter(
SubscriptionSizeDao.sizes_by_name(
selectedsubscription).values_list('shares', flat=True)
or []), 1)
if shares < min_num_shares or not subscriptionform.is_valid():
shareerror = shares < min_num_shares
else:
size = next(
iter(
SubscriptionSizeDao.sizes_by_name(
selectedsubscription).values_list('size', flat=True)
or []), 0)
if size > 0:
session_subscription = Subscription(
**subscriptionform.cleaned_data)
session_subscription.depot = DepotDao.depot_by_id(
request.POST.get("depot"))
session_subscription.primary_member = member
session_subscription.size = size
if len(member_shares) < int(request.POST.get("shares")):
toadd = int(request.POST.get("shares")) - len(member_shares)
for num in range(0, toadd):
member_shares.append(Share(member=member, paid_date=None))
elif len(member_shares) > int(request.POST.get("shares")):
toremove = len(member_shares) - int(request.POST.get("shares"))
for num in range(0, toremove):
member_shares.pop()
if request.POST.get("add_member"):
request.session['create_subscription'] = session_subscription
request.session['create_member_shares'] = member_shares
return redirect("/my/cosubmember/0")
else:
password = None
if member.pk is None:
member.save()
password = password_generator()
member.user.set_password(password)
member.user.save()
if session_subscription is not None:
session_subscription.save()
member.subscription_id = session_subscription.id
member.save()
send_welcome_mail(
member.email, password,
hashlib.sha1((member.email +
str(member.id)).encode('utf8')).hexdigest())
for co_member in co_members:
co_member.subscription_id = session_subscription.id
co_member.save()
pw = None
if co_member.confirmed is False:
pw = password_generator()
co_member.user.set_password(pw)
co_member.user.save()
send_been_added_to_subscription(
co_member.email, pw, member.get_name(), shares,
hashlib.sha1(
(co_member.email +
str(co_member.id)).encode('utf8')).hexdigest())
for share in member_shares + co_members_shares:
if share.id is None:
if share.member.email == member.email:
share.member = member
else:
share.member = list(
(co_member for co_member in co_members
if co_member.email == share.member.email))[0]
share.save()
send_share_created_mail(share)
request.session['create_subscription'] = None
request.session['create_co_members'] = []
request.session['create_co_members_shares'] = []
request.session['create_member_shares'] = []
if request.user.is_authenticated():
return redirect("/my/home")
else:
return redirect("/my/welcome")
renderdict = {
'co_member_shares': co_member_shares,
'existing_member_shares': existing_member_shares,
'member': member,
'subscription_sizes': SubscriptionSizeDao.all_sizes_ordered(),
'depots': DepotDao.all_depots(),
'selected_depot': selected_depot,
'selected_subscription': selectedsubscription,
'shareerror': shareerror,
'co_members': co_members,
'subscriptionform': subscriptionform
}
return render(request, "createsubscription.html", renderdict)
def get_menu_dict(request):
member = request.user.member
next_jobs = []
def filter_to_past_assignments(assignments):
res = []
for assignment in assignments:
if assignment.job.time.year == date.today(
).year and assignment.job.time < timezone.now():
res.append(assignment)
return res
subscription_size = 0
if member.subscription is not None:
partner_assignments = []
for subscription_member in member.subscription.recipients():
if subscription_member == member:
continue
partner_assignments.extend(
filter_to_past_assignments(
AssignmentDao.assignments_for_member(subscription_member)))
userassignments = filter_to_past_assignments(
AssignmentDao.assignments_for_member(member))
subscription_size = member.subscription.required_assignments()
assignmentsrange = list(
range(
0,
max(subscription_size,
len(userassignments) + len(partner_assignments))))
for assignment in AssignmentDao.assignments_for_member(
member).order_by("job__time"):
if assignment.job.time > timezone.now():
next_jobs.append(assignment.job)
else:
assignmentsrange = None
partner_assignments = []
userassignments = []
next_jobs = []
depot_admin = DepotDao.depots_for_contact(request.user.member)
area_admin = ActivityAreaDao.areas_by_coordinator(request.user.member)
menu_dict = {
'user':
request.user,
'assignmentsrange':
assignmentsrange,
'userassignments_total':
len(userassignments),
'userassignemnts_core':
len([
assignment for assignment in userassignments
if assignment.is_core()
]),
'partner_assignments_total':
len(userassignments) + len(partner_assignments),
'partner_assignments_core':
len(userassignments) + len([
assignment
for assignment in partner_assignments if assignment.is_core()
]),
'subscription_size':
subscription_size,
'next_jobs':
next_jobs,
'can_filter_members':
request.user.has_perm('juntagrico.can_filter_members'),
'can_filter_subscriptions':
request.user.has_perm('juntagrico.can_filter_subscriptions'),
'can_send_mails':
request.user.has_perm('juntagrico.can_send_mails'),
'operation_group':
request.user.has_perm('juntagrico.is_operations_group'),
'depot_admin':
depot_admin,
'area_admin':
area_admin,
'show_core':
ActivityAreaDao.all_core_areas().count() > 0,
'show_extras':
JobExtraDao.all_job_extras().count() > 0,
'depot_list_url':
settings.MEDIA_URL + settings.MEDIA_ROOT + "/dpl.pdf",
}
enrich_menu_dict(request, menu_dict)
return menu_dict
