def get_context_data(self, **kwargs):
context_data = super().get_context_data(**kwargs)
context_data.update({
'page':
context_data['page_obj'],
'paginator_range':
func.get_paginator_range(context_data['page_obj']),
'url_paginator':
self.get_paginator_url(),
'has_perm':
self.request.user.is_authenticated()
and self.owner.has_perm(self.request.user),
'item_id':
self.owner.pk,
'item_type':
self.t,
'pageNum':
self.page,
'url_parameter':
self.owner.pk,
'uploaderURL':
self.get_uploader_url(),
'structureURL':
self.get_structure_url(),
'removeURL':
self.get_remove_url()
})
return context_data
def get_favorite(request, page=1):
if request.POST:
if len(request.POST) > 1:
toDelete = request.POST.getlist("del[]")
cabinet = Cabinet.objects.filter(user=request.user)
favorites = Favorite.objects.filter(c2p__parent=cabinet, p2c__child__in=toDelete)
favorites.delete()
user = request.user
curr_url = "favorite"
cabinet = Cabinet.objects.filter(user=user)
favorites = Favorite.active.get_active_related().filter(c2p__parent=cabinet).order_by('-create_date')
products = Product.active.get_active_related().filter(c2p__parent__c2p__parent=cabinet, c2p__parent=favorites).order_by("-c2p__parent__create_date")
attr = ("IMAGE", 'NAME', 'CURRENCY', 'COST', 'COUPON_DISCOUNT', 'DISCOUNT')
result = func.setPaginationForItemsWithValues(products, *attr, page_num=5, page=page)
favoriteList = result[0]
for favorite in favoriteList.values():
real_cost = _getRealCost(favorite)
favorite.update({'AFTER_DISCOUNT': real_cost})
page = result[1]
paginator_range = func.get_paginator_range(page)
url_paginator = "profile:favorite_paginator"
return render_to_response('Cabinet/favorite.html', {'user': user, 'curr_url': curr_url,
'favoriteList': favoriteList, 'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator},
context_instance=RequestContext(request))
def _tab_structure(request, company, page=1):
"""
Company view's tab 'Structure' processing.
"""
organization = get_object_or_404(Company, pk=company)
if request.is_ajax() and not request.user.is_anonymous() \
and request.user.is_authenticated():
item_id = request.POST.get("id", None)
name = request.POST.get('name', '').strip()
action = request.POST.get("action", None)
request_type = request.POST.get("type", None)
if not (request_type in ('department', 'vacancy')) and action is not None:
return HttpResponseBadRequest()
if not organization.has_perm(request.user) and action is not None:
return HttpResponseBadRequest()
if action == "add" and len(name) > 0:
if request_type == 'department':
organization.create_department(name, request.user)
elif item_id is not None: # new vacancy
obj = get_object_or_404(organization.departments, pk=item_id)
organization.create_vacancy(name, obj, request.user)
elif action == "edit" and item_id is not None and len(name) > 0:
if request_type == 'department':
obj = get_object_or_404(organization.departments, pk=item_id)
else:
obj = get_object_or_404(organization.vacancies, pk=item_id)
obj.name = name
obj.save()
elif action == "remove" and item_id is not None:
if request_type == 'department':
obj = get_object_or_404(organization.departments, pk=item_id)
else:
obj = get_object_or_404(organization.vacancies, pk=item_id)
obj.delete()
departments = organization.departments.all().prefetch_related('vacancies').order_by('name')
paginator = Paginator(departments, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "companies:tab_structure_paged"
template_params = {
'has_perm': organization.has_perm(request.user),
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': company,
'item_pk': company,
}
return render(request, 'b24online/Companies/tabStructure.html', template_params)
def reviewList(request):
page = request.GET.get('page', 1)
result = func.getItemsListWithPagination("Review", "NAME", "ACTIVE_FROM", "DETAIL_TEXT", "IMAGE", page=page)
reviewList = result[0]
page = result[1]
paginator_range = func.get_paginator_range(page)
user = request.user
return render_to_response("Reviews/index.html", locals())
def get_context_data(self, **kwargs):
context_data = super().get_context_data()
context_data.update(url_paginator=self.get_url_paginator(),
paginator_range=func.get_paginator_range(
context_data['page_obj']),
title=self.get_title(),
current_section=self.get_current_section())
return context_data
def get_paged_data(self):
paginator = Paginator(self.get_queryset(), self.on_page, allow_empty_first_page=True)
page = paginator.page(self.current_page)
paginator, page, queryset, is_paginated = (paginator, page, page.object_list, page.has_other_pages())
return {
'page': page,
'on_page': self.on_page,
'paginator': paginator,
'page_obj': page,
'is_paginated': is_paginated,
'paginator_range': func.get_paginator_range(page),
self.queryset_key: queryset
}
def get_context_data(self, **kwargs):
context = super(ItemsList, self).get_context_data(**kwargs)
context.update({
'applied_filters':
self.applied_filters,
'sortField1':
self.sortField1,
'sortField2':
self.sortField2,
'order1':
self.order1,
'order2':
self.order2,
'page':
context['page_obj'],
'paginator_range':
func.get_paginator_range(context['page_obj']),
'url_parameter':
self.url_parameter,
'url_paginator':
self.url_my_paginator if self.is_my() else self.url_paginator,
'items_perms':
None, # Deprecated
'current_path':
self.request.get_full_path(),
'addNew':
'' if not self.get_add_url() else reverse(self.get_add_url()),
'current_section':
self.current_section,
'styles':
self.styles,
'scripts':
self.scripts,
'available_filters':
list(self.filter_list.keys()),
'model':
self.model.__name__,
'is_my':
self.is_my(),
})
if isinstance(context['object_list'], SearchEngine):
object_ids = [hit.django_id for hit in context['object_list']]
context['object_list'] = \
self.optimize_queryset(self.model.objects.filter(pk__in=object_ids)) \
.order_by(*self._get_sorting_params())
return context
def getAllNewProducts(request, page=1):
products = Product.objects.filter(sites=settings.SITE_ID).order_by("-pk")
result = func.setPaginationForItemsWithValues(products, "NAME", 'DETAIL_TEXT', 'IMAGE', 'COST', 'CURRENCY',
page_num=15, page=page)
products_list = result[0]
products_ids = [key for key, value in products_list.items()]
companies = Company.objects.filter(p2c__child_id__in=products_ids)
items = Item.objects.filter(p2c__child_id__in=companies, p2c__type="dependence", pk__in=Country.objects.all(),
p2c__child__p2c__child__in=products_ids).values("country", "p2c__child_id",
'p2c__child__p2c__child', 'pk')
items_id =[]
for item in items:
items_id.append(item['pk'])
items_id.append(item['p2c__child_id'])
items_id = set(items_id)
itemsWithAttribute = Item.getItemsAttributesValues(("NAME", "IMAGE"), items_id)
for item in items:
products_list[item['p2c__child__p2c__child']].update({'COMPANY_NAME': itemsWithAttribute[item['p2c__child_id']]['NAME']})
products_list[item['p2c__child__p2c__child']].update({'COMPANY_IMAGE': itemsWithAttribute[item['p2c__child_id']]['IMAGE']})
products_list[item['p2c__child__p2c__child']].update({'COMPANY_ID': item['p2c__child_id']})
products_list[item['p2c__child__p2c__child']].update({'COUNTRY_NAME': itemsWithAttribute[item['pk']]['NAME']})
products_list[item['p2c__child__p2c__child']].update({'COUNTRY_ID': item['pk']})
page = result[1]
paginator_range = func.get_paginator_range(page)
url_paginator = "products:products_paginator"
return render_to_response("Product/new.html", {'products_list': products_list, 'page': page,
'paginator_range':paginator_range, 'url_paginator': url_paginator,
'user': request.user}, context_instance=RequestContext(request))
def _getComment(parent_id, page):
comments = Comment.getCommentOfItem(parent_id=parent_id)
comments = comments.order_by('-pk')
result = func.setPaginationForItemsWithValues(comments, "DETAIL_TEXT", page_num=3, page=page)
commentsList = result[0]
for id ,comment in commentsList.items():
comment['User'] = comments.get(pk=id).create_user
comment['Date'] = comments.get(pk=id).create_date
page = result[1]
paginator_range = func.get_paginator_range(page)
commentsList = OrderedDict(sorted(commentsList.items(), reverse=True))
return commentsList, paginator_range, page
def _tab_innovation_projects(request, tpp, page=1):
projects = InnovationProject.get_active_objects().filter(organization=tpp)
paginator = Paginator(projects, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "tpp:tab_innov_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': tpp
}
return render(request, 'b24online/Companies/tabInnov.html', template_params)
def _tab_tenders(request, tpp, page=1):
tenders = Tender.objects.filter(organization=tpp)
paginator = Paginator(tenders, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "tpp:tab_tenders_paged"
template_arams = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': tpp
}
return render(request, 'b24online/Tpp/tabTenders.html', template_arams)
def _tab_exhibitions(request, tpp, page=1):
exhibitions = Exhibition.get_active_objects().filter(organization=tpp)
paginator = Paginator(exhibitions, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "tpp:tab_exhibitions_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': tpp
}
return render(request, 'b24online/Tpp/tabExhibitions.html', template_params)
def _tab_video(request, company, page=1):
video = Video.get_active_objects().filter(organization=company)
paginator = Paginator(video, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "companies:tab_video_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': company
}
return render(request, 'b24online/Companies/tabVideo.html', template_params)
def _tabs_exhibitions(request, company, page=1):
exhibitions = Exhibition.get_active_objects().filter(organization=company)
paginator = Paginator(exhibitions, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "companies:tab_exhibitions_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': company
}
return render(request, 'b24online/Companies/tabExhibitions.html', template_params)
def _tab_proposals(request, company, page=1):
proposals = BusinessProposal.get_active_objects().filter(organization=company)
paginator = Paginator(proposals, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "companies:tab_proposal_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': company
}
return render(request, 'b24online/Companies/tabProposal.html', template_params)
def _tab_b2c_products(request, company, page=1):
products = B2CProduct.get_active_objects().filter(company=company)
paginator = Paginator(products, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "companies:tab_b2c_products_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': company
}
return render(request, 'b24online/Companies/tab_B2CProducts.html', template_params)
def _tab_companies(request, tpp, page=1):
companies = Company.get_active_objects().filter(parent=tpp)
paginator = Paginator(companies, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "tpp:tab_companies_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': tpp
}
return render(request, 'b24online/Tpp/tabCompanies.html', template_params)
def get_order_history(request, page=1):
#------order history of user with pagination-----#
user = request.user
curr_url = "order_history"
cabinet = Cabinet.objects.filter(user=user)
orders = Order.objects.filter(c2p__parent__in=cabinet).order_by("-pk")
attr = ("IMAGE", 'NAME', 'CURRENCY', 'COST', 'QUANTITY', 'ADDRESS_CITY', 'ADDRESS_COUNTRY', 'ADDRESS')
result = func.setPaginationForItemsWithValues(orders, *attr, page_num=5, page=page)
orderList = result[0]
#Paginator
page = result[1]
paginator_range = func.get_paginator_range(page)
url_paginator = "profile:paginator"
return render_to_response("Cabinet/orderHistory.html", {"user": user, 'curr_url': curr_url,
'orderList': orderList, 'paginator_range': paginator_range,
'url_paginator': url_paginator, 'page': page},
context_instance=RequestContext(request))
def newsList(request, page=1):
user = request.user
page = page
result = func.getItemsListWithPagination("News",
"NAME",
"Active_From",
"DETAIL_TEXT",
"IMAGE",
page=page)
newsList = result[0]
page = result[1]
paginator_range = func.get_paginator_range(page)
url_paginator = "news:paginator"
contrySorted = func.sortByAttr("Country", "NAME")
sorted_id = [coun.id for coun in contrySorted]
countryList = Item.getItemsAttributesValues(("NAME", ), sorted_id)
return render_to_response("News/index.html", locals())
def _tab_staff(request, tpp, page=1):
organization = get_object_or_404(Chamber, pk=tpp)
if request.is_ajax() and not request.user.is_anonymous() and request.user.is_authenticated():
action = request.POST.get('action', False)
action = action if action else request.GET.get('action', None)
if not organization.has_perm(request.user) and action is not None:
return HttpResponseBadRequest()
if action == "department":
departments = [{'name': _("Select department"), "value": ""}]
for department in organization.departments.all().order_by('name'):
departments.append({"name": department.name, "value": department.pk})
return JsonResponse(departments, safe=False)
elif action == "vacancy":
department = int(request.GET.get("department", 0))
if department <= 0:
return HttpResponseBadRequest()
vacancies = [{'name': _("Select vacancy"), "value": ""}]
for department in organization.departments.all():
for vacancy in department.vacancies.all().order_by('name'):
vacancies.append({"name": vacancy.name, "value": vacancy.pk})
return JsonResponse(vacancies, safe=False)
elif action == "add":
user = request.POST.get('user', "").strip()
department = int(request.POST.get('department', 0))
vacancy = int(request.POST.get('vacancy', 0))
if not user or department <= 0 or vacancy <= 0:
return HttpResponseBadRequest()
try:
user = get_user_model().objects.get(email=user, is_active=True)
vacancy = Vacancy.objects.get(pk=vacancy, department__organization=organization)
except ObjectDoesNotExist:
return HttpResponseBadRequest(_('User not found'))
# One user for vacancy
if vacancy.user:
return HttpResponseBadRequest(_("The vacancy already have employee attached"))
if user.work_positions.filter(department__organization=organization).exists():
return HttpResponseBadRequest(_("The user already employed in your organization"))
admin = bool(int(request.POST.get('admin', 0)))
vacancy.assign_employee(user, admin)
elif action == "remove":
cabinet = int(request.POST.get('id', 0))
if cabinet > 0:
user = get_object_or_404(get_user_model(), pk=cabinet)
vacancy = get_object_or_404(Vacancy, user=user, department__organization=organization)
vacancy.remove_employee()
users = get_user_model().objects.filter(is_active=True, work_positions__department__organization=organization).distinct() \
.select_related('profile').prefetch_related('work_positions', 'work_positions__department')
paginator = Paginator(users, 10)
page = paginator.page(page)
paginator_range = func.get_paginator_range(page)
url_paginator = "tpp:tab_staff_paged"
template_params = {
'page': page,
'paginator_range': paginator_range,
'url_paginator': url_paginator,
'url_parameter': tpp,
'item_pk': tpp,
'organization': organization,
'has_perm': organization.has_perm(request.user)
}
return render(request, 'b24online/Tpp/tabStaff.html', template_params)
