def all_specials(request, service_name):
if not service_name:
return dict(redirect=reverse('catalog:all-specials',
kwargs=dict(service_name=Service.objects.all()[0].codename)))
try:
service = Service.objects.get(codename=service_name)
except Service.DoesNotExist:
service = None
city_id = request.session.get('city', None)
if not city_id:
try:
city_id = request.user.city.id
except AttributeError:
return dict(redirect=reverse('index'))
specials = Special.objects.filter(is_active=True, owner__city__id=city_id)
if service:
specials = specials.filter(owner__service=service)
page = request.GET.get('page', '1')
page = int(page) if page.isdigit() else 1
specials = paginate(specials, page,
pages=settings.SPECIALS_OBJECTS_ON_PAGE)
dt = {'specials': specials, 'services': Service.objects.all(),
'service_name': service_name}
if settings.SAUSAGE_SCROLL_ENABLE and int(page) != 1:
dt.update({'_template': 'catalog/include/specials.html'})
return dt
def service_partner_specials(request, pk):
dt = get_service_data(request, pk)
items = dt['items']
items = items.filter(is_special_active=True)
page = request.GET.get('page', 1)
items = paginate(items, page, pages=settings.ITEMS_ON_PAGE)
dt['items'] = items
return dt
def service_page(request, pk, title='', category_pk=None):
dt = get_service_data(
request, pk=pk, title=title, category_pk=category_pk
)
items = dt['items']
items = items.order_by('container__weight', 'weight', '-id')
page = request.GET.get('page', 1)
items = paginate(items, page, pages=settings.ITEMS_ON_PAGE)
dt['items'] = items
if settings.SAUSAGE_SCROLL_ENABLE and int(page) != 1:
dt.update({'_template': 'catalog/include/service_page_items.html'})
return dt
def index(request):
posts = Post.objects.all()
page = request.GET.get('page', 1)
services = posts.values('type__service').distinct()
posts = paginate(posts, page, pages=settings.DEFAULT_PAGES_COUNT)
#c = posts.count()
#_posts = []
#_posts.append(posts[c/2:])
#_posts.append(posts[:c/2])
dt = {'posts': posts, 'services': services}
if settings.SAUSAGE_SCROLL_ENABLE:
if int(page) != 1:
dt.update({'_template': 'blog/include/posts_index.html'})
return dt
def category(request, pk):
category = get_object_or_404(PostType, pk=pk)
posts = Post.objects.filter(type=category)
services = posts.values('type__service').distinct()
page = request.GET.get('page', 1)
posts = paginate(posts, page, pages=settings.DEFAULT_PAGES_COUNT)
#_posts = []
#c = posts.count()
#_posts.append(posts[c/2:])
#_posts.append(posts[:c/2])
dt = {
'posts': posts, 'services': services,
'category': category
}
if settings.SAUSAGE_SCROLL_ENABLE:
if int(page) != 1:
dt.update({'_template': 'blog/include/posts_index.html'})
return dt
def search(request):
q = request.GET.get('q', '')
if q:
posts = (
Post.objects.filter(title__icontains=q) |
Post.objects.filter(announce__icontains=q) |
Post.objects.filter(content__icontains=q)
)
else:
posts = Post.objects.all()
page = request.GET.get('page', 1)
services = posts.values('type__service').distinct()
posts = paginate(posts, page, pages=settings.DEFAULT_PAGES_COUNT)
#c = posts.count()
#_posts = []
#_posts.append(posts[c/2:])
#_posts.append(posts[:c/2])
dt = {'posts': posts, 'G': request.GET, 'search': True, 'services': services}
if settings.SAUSAGE_SCROLL_ENABLE:
if int(page) != 1:
dt.update({'_template': 'blog/include/posts_index.html'})
return dt
def catalog_list(request, service_pk=0, codename='', is_special=False):
service = (
get_object_or_None(Service, pk=service_pk)
or get_object_or_None(Service, codename=codename)
)
search_type = request.GET.get('search-type', 0)
is_special = request.GET.get('is_special', is_special)
cardpay = request.GET.get('cardpay', False)
# container_list = request.GET.getlist('type') or None
categories_list = request.GET.getlist('type', [])
categories_list = categories_list if all(categories_list) else []
minimal_cost = request.GET.get('minimal_cost', 0)
title = request.GET.get('title', '')
by_rating = request.GET.get('by_rating', False)
nlat, mlat, nlng, mlng = map(request.GET.get, ['nlat', 'mlat', 'nlng',
'mlng'])
free_deliver = request.GET.get('free_deliver', False)
state = request.GET.get('state', 1)
if not service:
raise Http404("No such service found")
# select only that cities where user is bind to
geoip = GeoIP()
ip = request.GET.get('REMOTE_ADDR', '127.0.0.1')
city = request.session.get(
'city',
request.user.city
if request.user.is_authenticated() else \
(geoip.city(ip) or {}).get('city', None)
)
owners_ids = [id_dict.values()[0] for id_dict in User.objects.filter(is_published=True).values('id')]
containers = Container.objects.select_related('owner').filter(
service=service, owner__in=owners_ids).order_by('owner') #@TODO: select_related
state = int(state) if isinstance(state, basestring) else 1
if state:
now = datetime.now().replace(second=0, microsecond=0)
week_day = now.isoweekday()
prev_week_day = week_day - 1 if week_day > 1 else 7
qset = (
# since < until
Q(until__gte=now, since__lte=now, weekday=week_day) |
# since > until
(Q(until__lt=F('since')) &
Q(since__lte=now, weekday=week_day)) |
# next day jump
(Q(until__lt=F('since')) &
Q(until__gte=now, weekday=prev_week_day))
)
td = TimeNDay.objects.filter(
Q(is_active=True) & qset
)
schedules = Schedule.objects.filter(timenday_schedule_set__in=td)
containers = containers.filter(owner__schedule_user_set__in=schedules)
if by_rating:
containers = containers.order_by('-mean_rating')
if city:
containers = containers.filter(owner__city=city)
else:
top_city = City.objects.all()[0]
containers = containers.filter(owner__city=top_city)
if free_deliver:
containers = containers.exclude(owner__avarage_cost=None)
# containers = containers.filter(owner__avarage_deliver_cost=0)
unique_containers = containers.filter(
container=None).order_by('title').distinct('title')
if categories_list:
categories = Category.objects.filter(pk__in=categories_list)
categories = categories | \
Category.objects.filter(parent__in=categories) # 2 lvl
categories = categories | \
Category.objects.filter(parent__in=categories) # 3 lvl
containers = containers. \
filter(category__in=categories) # categories_list)
# containers = (
# containers.filter(container__title__in=container_list) |
# containers.filter(title__in=container_list)
# )
if isinstance(minimal_cost, basestring):
minimal_cost = int(minimal_cost) if minimal_cost.isdigit() else 0
if minimal_cost:
# owner__avarage_cost__lte=minimal_cost)
containers = containers.filter(owner__minimal_cost__lte=minimal_cost)
if cardpay:
containers = containers.exclude(owner__has_online_payment=False)
if all((nlat, mlat, nlng, mlng)):
positions = GPos.objects.filter(
lat__gte=nlat, lat__lte=mlat,
lng__gte=nlng, lng__lte=mlng
)
containers = containers.filter(owner__gpos_user_set__in=positions)
# containers = (
# containers.filter(
# owner__glat__gte=nlat, owner__glat__lte=mlat,
# owner__glng__gte=nlng, owner__glng__lte=mlng
# )
# )
has_coords = 'nlat' in request.GET
has_coords = has_coords and 'mlat' in request.GET
has_coords = has_coords and 'nlng' in request.GET
has_coords = has_coords and 'mlng' in request.GET
if has_coords and not all((nlat, mlat, nlng, mlng)):
containers = Container.objects.filter(id=-1)
items = Item.objects.filter(container__in=containers)
new_ones = request.GET.get('new_ones', False)
one_week = datetime.now() - timedelta(weeks=1)
if search_type == '1': # by items
items = items.filter(
title__icontains=title
)
if new_ones:
items = items.filter(container__owner__publish_date__gte=one_week)
if is_special:
items = items.filter(is_special_active=True)
else: # by containers
containers = containers.filter(
owner__service_name__icontains=title).order_by(
'owner').distinct('owner')
if new_ones:
containers = containers.filter(owner__publish_date__gte=one_week)
if is_special:
items = Item.objects.filter(is_special_active=True,
container__service=service)
pks = containers.exclude(owner__special_owner_set=None)
containers = (
Container.objects.filter(item_container_set__in=items) |
Container.objects.filter(pk__in=pks)
)
if by_rating:
containers = containers.order_by('-mean_rating')
# containers = containers.filter(item_container_set__in=items)
page = request.GET.get('page', 1)
containers = Container.objects.filter(
pk__in=containers).distinct().order_by('-mean_rating').distinct()
categories = Category.objects.filter(service=service)
# ordering
items = Item.objects.filter(
pk__in=items.order_by('-cost').values('pk')
).distinct().order_by('-cost')
order_by = request.GET.get('order_by', '-cost')
order_by_asc = not order_by.startswith('-')
if not order_by_asc:
order_by = order_by[1:]
order_by_prefix = '-'
order_by_prefix_future = ''
else:
order_by_prefix = ''
order_by_prefix_future = '-'
if order_by in settings.CATALOG_ORDER_BY:
items = items.order_by(order_by_prefix + order_by)
if by_rating:
items = items.order_by('-container__mean_rating')
# paging
containers = paginate(containers, page, pages=settings.DEFAULT_PAGES_COUNT)
items = paginate(items, page, pages=settings.DEFAULT_PAGES_COUNT)
dt = {
'service': service,
'categories': categories,
'containers': containers,
'items': items,
'unique_containers': unique_containers,
'search_type': search_type,
'types': [int(i if i.isdigit() else 0) for i in
request.GET.getlist('type')],
'G': request.GET,
# 'request': request,
'order_by': order_by,
'order_by_prefix': order_by_prefix,
'order_by_prefix_future': order_by_prefix_future,
}
if settings.SAUSAGE_SCROLL_ENABLE:
if int(search_type) == 1 and int(page) != 1:
dt.update({'_template': 'catalog/include/items.html'})
elif int(page) != 1:
dt.update({"_template": "catalog/include/partners.html"})
return dt
