Example #1
0
def home(request, template="base_index.html"):
    # Display the category, its child categories, and its products.

    if request.method == "GET":
        currpage = request.GET.get("page", 1)
    else:
        currpage = 1

    featured = display_featured()

    count = config_value("SHOP", "NUM_PAGINATED")

    paginator = Paginator(featured, count)

    is_paged = False
    page = None

    try:
        paginator.validate_number(currpage)
    except EmptyPage:
        return bad_or_missing(request, _("Invalid page number"))

    is_paged = paginator.num_pages > 1
    page = paginator.page(currpage)

    ctx = {
        "all_products_list": page.object_list,
        "is_paginated": is_paged,
        "page_obj": page,
        "paginator": paginator,
    }

    return render(request, template, ctx)
Example #2
0
File: home.py Project: tcv1/satchmo
def home(request, template="shop/index.html"):
    # Display the category, its child categories, and its products.

    if request.method == "GET":
        currpage = request.GET.get('page', 1)
    else:
        currpage = 1

    featured = display_featured()

    count = config_value('PRODUCT', 'NUM_PAGINATED')

    paginator = Paginator(featured, count)

    is_paged = False
    page = None

    try:
        paginator.validate_number(currpage)
    except EmptyPage:
        return bad_or_missing(request, _("Invalid page number"))

    is_paged = paginator.num_pages > 1
    page = paginator.page(currpage)

    ctx = RequestContext(
        request, {
            'all_products_list': page.object_list,
            'is_paginated': is_paged,
            'page_obj': page,
            'paginator': paginator
        })

    return render_to_response(template, context_instance=ctx)
Example #3
0
File: home.py Project: 34/T
def home(request, template="shop/index.html"):
    # Display the category, its child categories, and its products.
    
    if request.method == "GET":
        currpage = request.GET.get('page', 1)
    else:
        currpage = 1
        
    featured = display_featured()
    
    count = config_value('PRODUCT','NUM_PAGINATED')
    
    paginator = Paginator(featured, count)
    
    is_paged = False
    page = None
    
    try:
        paginator.validate_number(currpage)
    except EmptyPage:
        return bad_or_missing(request, _("Invalid page number"))
            
    is_paged = paginator.num_pages > 1
    page = paginator.page(currpage)
        
    ctx = RequestContext(request, {
        'all_products_list' : page.object_list,        
        'is_paginated' : is_paged,
        'page_obj' : page,
        'paginator' : paginator
    })
    
    return render_to_response(template, context_instance=ctx)
Example #4
0
    def __init__(self,
                 request,
                 qs,
                 ordering: Ordering = None,
                 extras: dict = None,
                 **kwargs):
        kwargs.setdefault('content_type', 'application/json')

        # Ordering
        if isinstance(qs, QuerySet):
            ordering = ordering if ordering else Ordering.create_from_request(
                request)
            qs = qs.order_by(str(ordering))

        paginate = request.GET.get('paginate', 'true') == 'true'

        if paginate:
            limit = int(
                request.GET.get('limit', settings.PAGINATION['DEFAULT_LIMIT']))
            page = int(request.GET.get('page', 1))

            paginator = Paginator(qs, limit)

            try:
                paginator.validate_number(page)
            except EmptyPage as e:
                raise ProblemDetailException(
                    request,
                    title=_('Page not found'),
                    status=HTTPStatus.NOT_FOUND,
                    previous=e,
                    detail_type='out_of_range',
                    detail=_('That page contains no results'))

            items = paginator.get_page(page)
            num_pages = paginator.num_pages
            total = paginator.count
        else:
            limit = None
            page = 1
            items = qs
            num_pages = 1
            total = qs.count()

        data = {}
        if extras:
            for key, item in extras.items():
                data[key] = item

        data['items'] = items
        data['metadata'] = {
            'page': page,
            'limit': limit,
            'pages': num_pages,
            'total': total
        }

        super().__init__(request, data, **kwargs)
Example #5
0
def category_view_kamel(request,
                        slug,
                        parent_slugs='',
                        template='product/category.html'):
    """Display the category, its child categories, and its products.

    Parameters:
     - slug: slug of category
     - parent_slugs: ignored
    """
    if request.method == "GET":
        currpage = request.GET.get('page', 1)
        town = request.GET.get('town')
    else:
        currpage = 1
        town = 'Gdansk'

    is_paged = False
    page = None

    try:
        category = Category.objects.get_by_site(slug=slug)
        products = list(category.active_products())
        sale = find_best_auto_discount(products)
        count = config_value('PRODUCT', 'NUM_PAGINATED')
        paginator = Paginator(products, count)
        try:
            paginator.validate_number(currpage)
        except EmptyPage:
            return bad_or_missing(request, _("Invalid page number"))
        is_paged = paginator.num_pages > 1
        page = paginator.page(currpage)

    except Category.DoesNotExist:
        return bad_or_missing(
            request, _('The category you have requested does not exist.'))

    child_categories = category.get_all_children()

    ctx = {
        'category': category,
        'child_categories': child_categories,
        'sale': sale,
        'town': town,
        'products': page.object_list,
        'is_paginated': is_paged,
        'page_obj': page,
        'paginator': paginator
    }
    index_prerender.send(Product,
                         request=request,
                         context=ctx,
                         category=category,
                         object_list=products)
    return render_to_response(template,
                              context_instance=RequestContext(request, ctx))
Example #6
0
 def test_invalid_page_number(self):
     """
     Invalid page numbers result in the correct exception being raised.
     """
     paginator = Paginator([1, 2, 3], 2)
     with self.assertRaises(InvalidPage):
         paginator.page(3)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(None)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number('x')
     # With no content and allow_empty_first_page=True, 1 is a valid page number
     paginator = Paginator([], 2)
     self.assertEqual(paginator.validate_number(1), 1)
Example #7
0
 def test_invalid_page_number(self):
     """
     Invalid page numbers result in the correct exception being raised.
     """
     paginator = Paginator([1, 2, 3], 2)
     with self.assertRaises(InvalidPage):
         paginator.page(3)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(None)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number('x')
     # With no content and allow_empty_first_page=True, 1 is a valid page number
     paginator = Paginator([], 2)
     self.assertEqual(paginator.validate_number(1), 1)
Example #8
0
def category_view(request, slug, parent_slugs='', template='product/category.html'):
    """Display the category, its child categories, and its products.

    Parameters:
     - slug: slug of category
     - parent_slugs: ignored
    """

    if request.method == "GET":
        currpage = request.GET.get('page', 1)
    else:
        currpage = 1

    try:
        category = Category.objects.get_by_site(slug=slug)
        products = list(category.active_products())
        sale = find_best_auto_discount(products)

    except Category.DoesNotExist:
        return bad_or_missing(request, _('The category you have requested does not exist.'))

    child_categories = category.get_all_children()

    count = config_value('PRODUCT','NUM_PAGINATED')

    paginator = Paginator(products, count)

    try:
        paginator.validate_number(currpage)
    except InvalidPage:
        return bad_or_missing(request, _("Invalid page number"))

    page = paginator.page(currpage)
    min_in_page = (count * (page.number - 1) + 1)
    max_in_page = min_in_page + (len(page.object_list) - 1)

    ctx = {
        'category': category,
        'child_categories': child_categories,
        'sale': sale,
        'products': page.object_list,
        'page_obj': page,
        'paginator': paginator,
        'min_in_page': min_in_page,
        'max_in_page': max_in_page
    }

    index_prerender.send(Product, request=request, context=ctx, category=category, object_list=products)
    return render_to_response(template, context_instance=RequestContext(request, ctx))
Example #9
0
def list_active_entity_items(request, charity_id):
    """Lists the items that an active entity can fulfill.
    Returns item names, paginated.
    """
    # Using an index on both entity and item FKs makes
    # the query slightly faster. But negligent.
    """
    QS Timing: 0.07431996694600161 w/ Select related + name
    QS Timing: 0.0004472580919982647 w/ sr + id
    QS Timing: 0.000249934839003231 w/o sr + name
    QS Timing: 0.00010671574200080158 w/o sr + id
    QS Timing: 1.2065899000049285e-05 w/ index on entity and item field
    QS Timing: 2.615080998225494e-06
    QS Timing: 2.5512770001796523e-06
    QS Timing: 3.3379649991047698e-06
    """
    if Charity.objects.filter(id=charity_id).exists():
        # Apparently using select/prefetch_related("item") makes it 10x slower
        qs = (WantedItem.objects.filter(
            charity_id=charity_id).order_by("item__name").values_list(
                "item__name", "condition"))
    else:
        raise Http404
    paginator = Paginator(qs, 50)
    try:
        num = paginator.validate_number(request.GET.get("page", 1))
    except (EmptyPage, PageNotAnInteger):
        raise Http404
    page_obj = paginator.page(num)
    return JsonResponse({
        "data": list(page_obj.object_list),
        "has_next": page_obj.has_next()
    })
Example #10
0
def get_rank(request):
    try:
        # 取排名
        result_list = Result.objects.filter(
            result__isnull=False).order_by("result")

        # 分页
        paginator = Paginator(result_list, PAGE_SIZE)
        page = request.GET.get('page')
        try:
            page = paginator.validate_number(page)
        except PageNotAnInteger:
            page = 1
        except EmptyPage:
            page = paginator.num_pages
        result_list = paginator.get_page(page)

        rst_list = []
        for result in result_list:
            rst_list.append({
                "userid": result.user.userid,
                "nickname": result.user.nickname,
                "figureurl": result.user.figureurl,
                "moves": result.moves,
                "result": result.result,
                "time": result.time
            })
        ret = {
            'status': True,
            'page': page,
            'rst_size': len(rst_list),
            'rst': rst_list
        }

        # 如果参数有userid,取个人排名
        userid = request.GET.get("userid")
        user_result = Result.objects.filter(user_id=userid).first()
        if userid and user_result:
            ret.update({
                "user_result": {
                    "userid": user_result.user.userid,
                    "nickname": user_result.user.nickname,
                    "figureurl": user_result.user.figureurl,
                    "moves": user_result.moves,
                    "result": user_result.result,
                    "time": user_result.time
                }
            })
            user_rank = Result.objects.filter(result__isnull=False).filter(
                result__lt=user_result.result).count() + 1
            ret.update({"user_rank": user_rank})

        return JsonResponse(ret)
        pass
    except Exception as e:
        ret = {'status': False}
        return JsonResponse(ret)
    def get_pagination_serializer(self, queryset, page_number=1):
        class SerializerClass(api_settings.DEFAULT_PAGINATION_SERIALIZER_CLASS):
            class Meta:
                object_serializer_class = RelationSerializer

        paginator = Paginator(queryset, api_settings.PAGINATE_BY,
                              allow_empty_first_page=True)
        page = paginator.page(paginator.validate_number(page_number))
        return SerializerClass(instance=page, context=self.context)
Example #12
0
 def pagination(cls, page=1, per_page=10, **kwargs):
     query_set = cls.fetch(**kwargs)
     paginator = Paginator(query_set, per_page)
     try:
         page = paginator.validate_number(page)
     except PageNotAnInteger:
         page = 1
     except EmptyPage:
         return [], paginator.count
     return paginator.get_page(page), paginator.count
Example #13
0
def paginate_search_results(object_class, search_results, page_size, page):
    """
    Takes edx-search results and returns a Page object populated
    with db objects for that page.

    :param object_class: Model class to use when querying the db for objects.
    :param search_results: edX-search results.
    :param page_size: Number of results per page.
    :param page: Page number.
    :return: Paginator object with model objects
    """
    paginator = Paginator(search_results['results'], page_size)

    # This code is taken from within the GenericAPIView#paginate_queryset method.
    # It is common code, but
    try:
        page_number = paginator.validate_number(page)
    except InvalidPage:
        if page == 'last':
            page_number = paginator.num_pages
        else:
            raise Http404(
                _("Page is not 'last', nor can it be converted to an int."))

    try:
        paged_results = paginator.page(page_number)
    except InvalidPage as e:  # pylint: disable=invalid-name
        raise Http404(
            _('Invalid page (%(page_number)s): %(message)s') % {
                'page_number': page_number,
                'message': str(e)
            })

    search_queryset_pks = [
        item['data']['pk'] for item in paged_results.object_list
    ]
    queryset = object_class.objects.filter(pk__in=search_queryset_pks)

    def ordered_objects(primary_key):
        """ Returns database object matching the search result object"""
        for obj in queryset:
            if obj.pk == primary_key:
                return obj

    # map over the search results and get a list of database objects in the same order
    object_results = map(ordered_objects, search_queryset_pks)
    paged_results.object_list = object_results

    return paged_results
Example #14
0
def paginate_search_results(object_class, search_results, page_size, page):
    """
    Takes edx-search results and returns a Page object populated
    with db objects for that page.

    :param object_class: Model class to use when querying the db for objects.
    :param search_results: edX-search results.
    :param page_size: Number of results per page.
    :param page: Page number.
    :return: Paginator object with model objects
    """
    paginator = Paginator(search_results['results'], page_size)

    # This code is taken from within the GenericAPIView#paginate_queryset method.
    # It is common code, but
    try:
        page_number = paginator.validate_number(page)
    except InvalidPage:
        if page == 'last':
            page_number = paginator.num_pages
        else:
            raise Http404("Page is not 'last', nor can it be converted to an int.")

    try:
        paged_results = paginator.page(page_number)
    except InvalidPage as exception:
        raise Http404(
            "Invalid page {page_number}: {message}".format(
                page_number=page_number,
                message=str(exception)
            )
        )

    search_queryset_pks = [item['data']['pk'] for item in paged_results.object_list]
    queryset = object_class.objects.filter(pk__in=search_queryset_pks)

    def ordered_objects(primary_key):
        """ Returns database object matching the search result object"""
        for obj in queryset:
            if obj.pk == primary_key:
                return obj

    # map over the search results and get a list of database objects in the same order
    object_results = map(ordered_objects, search_queryset_pks)
    paged_results.object_list = object_results

    return paged_results
Example #15
0
 def test_invalid_page_number(self):
     """
     Invalid page numbers result in the correct exception being raised.
     """
     paginator = Paginator([1, 2, 3], 2)
     with self.assertRaises(InvalidPage):
         paginator.page(3)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(None)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number('x')
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(1.2)
Example #16
0
 def test_invalid_page_number(self):
     """
     Invalid page numbers result in the correct exception being raised.
     """
     paginator = Paginator([1, 2, 3], 2)
     with self.assertRaises(InvalidPage):
         paginator.page(3)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(None)
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number('x')
     with self.assertRaises(PageNotAnInteger):
         paginator.validate_number(1.2)
Example #17
0
    def _get_dataset(self, path, page, per_page, query={}, cache_timeout=None):
        q = {}
        q.update(query)
        q['limit'] = per_page
        q['offset'] = (page - 1) * per_page

        response = self._request(path, q)

        if response is None:
            response = {
                'meta': {'total_count': 0},
                'objects': [],
            }

        meta = response['meta']
        objects = response['objects']

        dataset = API.DataSet(path, query, meta['total_count'], self._request)
        paginator = Paginator(dataset, per_page)
        return Page(objects, paginator.validate_number(page), paginator)
Example #18
0
def list_proposed_existing_item(request, proposed_item_pk):
    proposed_item_obj = get_object_or_404(ProposedItem, id=proposed_item_pk)
    paginator = Paginator(proposed_item_obj.item, 50)
    try:
        num = paginator.validate_number(request.GET.get("page", 1))
    except (EmptyPage, PageNotAnInteger):
        raise Http404
    page_obj = paginator.page(num)
    qs = (Item.objects.only("id",
                            "name").filter(id__in=page_obj.object_list,
                                           is_appropriate=True).order_by("id"))
    # Sort by id so that the condition array is also sorted
    conditions = [
        proposed_item_obj.item_condition[proposed_item_obj.item.index(x.id)]
        for x in qs
    ]
    return JsonResponse({
        "data": [(x.id, x.name) for x in qs],
        "condition": conditions,
        "has_next": page_obj.has_next(),
    })
    def _get_dataset(self, path, page, per_page, query={}, cache_timeout=None):
        q = {}
        q.update(query)
        q['limit'] = per_page
        q['offset'] = (page - 1) * per_page

        response = self._request(path, q)

        if response is None:
            response = {
                'meta': {
                    'total_count': 0
                },
                'objects': [],
            }

        meta = response['meta']
        objects = response['objects']

        dataset = API.DataSet(path, query, meta['total_count'], self._request)
        paginator = Paginator(dataset, per_page)
        return Page(objects, paginator.validate_number(page), paginator)
Example #20
0
def home(request):
    image_list = Image.objects.order_by('id')
    pageinator = Paginator(image_list, 10)
    page = request.GET.get('page')
    user_id = request.session.get('user_id', None)
    user = UserService.request_user_info(user_id) or None
    try:
        image_page = pageinator.page(page)
    except PageNotAnInteger:
        image_page = pageinator.page(1)
        page = "1"
    except EmptyPage:
        image_page = pageinator.page((pageinator.num_pages))

    scope = pageinator_range(pageinator.validate_number(page),
                             pageinator.num_pages)

    like_dic = {}
    i_like_dic = {}
    for image in image_page:
        like_count_model = ImageLikeCount.objects.filter(
            image_id=image.id).first()
        like_count = like_count_model.count if like_count_model else 0
        like_dic[image.id] = like_count
        i_like = UserService.request_has_collect_image(user_id, image.id)
        i_like_dic[image.id] = i_like

    tag_list = Tags.objects.order_by('id')
    context = {
        'image_list': image_page,
        'user': user,
        'page_range': range(scope[0], scope[1]),
        'image_likes': like_dic,
        'i_likes': i_like_dic,
        'tag_list': tag_list
    }
    return render(request, 'home.html', context)
Example #21
0
 def test_float_integer_page(self):
     paginator = Paginator([1, 2, 3], 2)
     self.assertEqual(paginator.validate_number(1.0), 1)
Example #22
0
    def paginate_queryset(self, queryset, page_size=None):
        """
        Paginate a queryset if required, either returning a page object,
        or `None` if pagination is not configured for this view.
        """
        deprecated_style = False
        if page_size is not None:
            warnings.warn('The `page_size` parameter to `paginate_queryset()` '
                          'is due to be deprecated. '
                          'Note that the return style of this method is also '
                          'changed, and will simply return a page object '
                          'when called without a `page_size` argument.',
                          PendingDeprecationWarning, stacklevel=2)
            deprecated_style = True
        else:
            # Determine the required page size.
            # If pagination is not configured, simply return None.
            page_size = self.get_paginate_by()
            if page_size == 0:
                from django.core.paginator import Page
                class Paginator():
                    def __init__(self, queryset):
                        self.count = queryset.count()
                        self.num_pages = 0
                    def validate_number(self, number):
                        return number
                paginator = Paginator(queryset)
                return Page(None, 0, paginator)
                
            if not page_size:
                return None

        if not self.allow_empty:
            warnings.warn(
                'The `allow_empty` parameter is due to be deprecated. '
                'To use `allow_empty=False` style behavior, You should override '
                '`get_queryset()` and explicitly raise a 404 on empty querysets.',
                PendingDeprecationWarning, stacklevel=2
            )

        paginator = self.paginator_class(queryset, page_size,
                                         allow_empty_first_page=self.allow_empty)
        page_kwarg = self.kwargs.get(self.page_kwarg)
        page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg)
        page = page_kwarg or page_query_param or 1
        try:
            page_number = paginator.validate_number(page)
        except InvalidPage:
            if page == 'last':
                page_number = paginator.num_pages
            else:
                raise Http404(_("Page is not 'last', nor can it be converted to an int."))
        try:
            page = paginator.page(page_number)
        except InvalidPage as e:
            raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
                                'page_number': page_number,
                                'message': str(e)
            })

        if deprecated_style:
            return (paginator, page, page.object_list, page.has_other_pages())
        return page
Example #23
0
 def test_no_content_allow_empty_first_page(self):
     # With no content and allow_empty_first_page=True, 1 is a valid page number
     paginator = Paginator([], 2)
     self.assertEqual(paginator.validate_number(1), 1)
Example #24
0
 def test_float_integer_page(self):
     paginator = Paginator([1, 2, 3], 2)
     self.assertEqual(paginator.validate_number(1.0), 1)
Example #25
0
def get_paginator(request, objs):
    paginator = Paginator(objs, PAGINATION_PAGE_SIZE)
    page_num = request.GET.get('page', 1)
    paginator.validate_number(page_num)
    page = paginator.get_page(page_num)
    return page, paginator
Example #26
0
 def test_no_content_allow_empty_first_page(self):
     # With no content and allow_empty_first_page=True, 1 is a valid page number
     paginator = Paginator([], 2)
     self.assertEqual(paginator.validate_number(1), 1)
Example #27
0
class CodingView(LoginRequiredMixin, ProjectViewMixin, DetailView):
    """
    View for working on a coding task.
    This is implemented as a detailview for coding tasks.
    """

    model = models.Task
    template_name = "project/coding.html"
    pk_url_kwarg = 'task_pk'

    def get_object(self, queryset=None):
        obj = super(CodingView, self).get_object(queryset)

        # Ensure the user is assigned to code this
        if not obj.is_assigned_to(self.request.user):
            raise PermissionDenied("You are not assigned to that task.")

        return obj

    def get_messages(self):
        task = self.object
        user = self.request.user

        # Ensure the user is assigned to code this
        if not task.is_assigned_to(user):
            raise PermissionDenied("You are not assigned to that task.")

        try:
            self.page = int(self.kwargs.get('page', 1))
        except ValueError:
            self.page = 1

        # Get the messages to code
        self.paginator = Paginator(task.get_messages(), CODING_BATCH_SIZE)

        try:
            self.page = self.paginator.validate_number(self.page)

        except PageNotAnInteger:
            # If page is not an integer, go to the first page.
            self.page = 1

        except EmptyPage:
            # If page is out of range (e.g. 9999), deliver last page of results.
            self.page = self.paginator.num_pages

        return self.paginator.page(self.page)


    def get_context_data(self, **kwargs):
        # Add some serialized json for bootstrapping the client-side app
        renderer = JSONRenderer()

        task = self.object
        kwargs['project_json'] = renderer.render(serializers.ProjectSerializer(self.get_project()).data)
        kwargs['task_json'] = renderer.render(serializers.TaskSerializer(self.object).data)
        kwargs['user_json'] = renderer.render(serializers.UserSerializer(self.request.user).data)
        kwargs['code_scheme_json'] = renderer.render(serializers.SchemeSerializer(task.scheme).data)

        return super(CodingView, self).get_context_data(**kwargs)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        task = self.object

        # The messages we expect to be coding
        msgs = self.get_messages()

        # Get all the legal code ids for this task's scheme
        all_code_ids = coding_models.Code.objects \
            .filter(code_group__in=task.scheme.code_groups.all()) \
            .values_list('pk', flat=True)
        all_code_ids = set(all_code_ids)  # for fast lookup

        # Extract all the new code ids for each message from the POST params
        message_code_ids = {}
        for msg in msgs:
            key = "messages[%d]" % msg.pk
            message_code_ids[msg.pk] = set()
            for code_id in self.request.POST.getlist(key):
                code_id = int(code_id)  # convert str to int

                if code_id not in all_code_ids:
                    return http.HttpResponseBadRequest("Code id %d not allowed" % code_id)

                message_code_ids[msg.pk].add(code_id)

        # Make sure all the messages match up
        if not message_code_ids or len(message_code_ids) != len(msgs):
            return http.HttpResponseBadRequest("Invalid set of messages coded")

        # Now create/delete instances as needed
        to_create = []
        to_delete = []
        for msg in msgs:
            current_instances = models.CodeInstance.objects \
                .filter(owner=self.request.user,
                        task=task,
                        message=msg) \
                .only('pk', 'code_id')

            new_code_ids = message_code_ids[msg.pk]

            for inst in current_instances:
                if inst.code_id not in new_code_ids:
                    # it has been un-checked
                    to_delete.append(inst)
                else:
                    # it is in both
                    new_code_ids.remove(inst.code_id)

            for code_id in new_code_ids:
                # any left over must be created
                to_create.append(models.CodeInstance(owner=self.request.user,
                                                     task=task,
                                                     message=msg,
                                                     code_id=code_id))

        models.CodeInstance.objects \
            .filter(pk__in=[inst.pk for inst in to_delete]) \
            .delete()

        models.CodeInstance.objects.bulk_create(to_create)

        next_page = self.page + 1
        return redirect('coding_page', project_slug=task.project.slug, task_pk=task.pk, page=next_page)