Example #1
0
 def get_object(self, request, slug='', file=''):
     obj = PageFile(slug=slugify(slug), name=file)
     page = Page(slug=slugify(slug))
     obj.page = page.versions.most_recent()
     obj.title = _('File %(filename)=s on page "%(pagename)s"') % {
         'filename': obj.name, 'pagename': obj.page.name}
     return obj
Example #2
0
 def render(self, context):
     try:
         cls = ''
         url = self.href
         page = context['page']
         if self.is_relative_link(url):
             if url.startswith('_files/'):
                 filename = file_url_to_name(url)
                 url = reverse('pages:file-info', args=[page.pretty_slug,
                                                    filename])
                 try:
                     file = PageFile.objects.get(slug__exact=page.slug,
                                                 name__exact=filename)
                     cls = ' class="file_%s"' % file.rough_type
                 except PageFile.DoesNotExist:
                     cls = ' class="missing_link"'
             else:
                 try:
                     page = Page.objects.get(slug__exact=slugify(url))
                     url = reverse('pages:show', args=[page.pretty_slug])
                 except Page.DoesNotExist:
                     # Check if Redirect exists.
                     if not Redirect.objects.filter(source=slugify(url)):
                         cls = ' class="missing_link"'
                     # Convert to proper URL: My%20page -> My_page
                     url = name_to_url(url_to_name(url))
                     url = reverse('pages:show', args=[url])
         return '<a href="%s"%s>%s</a>' % (url, cls,
                                           self.nodelist.render(context))
     except:
         return ''
Example #3
0
 def get_object(self, request, slug='', file=''):
     obj = PageFile(slug=slugify(slug), name=file)
     page = Page(slug=slugify(slug))
     obj.page = page.versions.most_recent()
     obj.title = _('File %(filename)s on page "%(pagename)s"') % {
         'filename': obj.name, 'pagename': obj.page.name}
     return obj
 def get(self, page_name):
     if page_name == '': page_name = 'home'  #set the homepage
     retrieved_from_memcache = True
     page = memcache.get(models.slugify(page_name), namespace='pages')
     if not page:
         retrieved_from_memcache = False
         page = models.Page.all().filter('url =',
                                         models.slugify(page_name)).get()
     if not page:
         if self.template_values[
                 'admin']:  #prefill the title if we have a page_name
             self.redirect('/edit?action=new&id=%s&item=page' % (page_name))
             return
         else:
             self.generate_error(404)
     else:  #standard page view
         if not retrieved_from_memcache:
             try:
                 memcache.add(models.slugify(page_name),
                              page,
                              namespace='pages')
             except:
                 pass
         self.generate('templates/view.html', {
             'page_title': page.title,
             'data': page,
         })
Example #5
0
 def render(self, context):
     try:
         cls = ''
         url = self.href
         page = context['page']
         if self.is_relative_link(url):
             if url.startswith('_files/'):
                 filename = file_url_to_name(url)
                 url = reverse('pages:file-info',
                               args=[page.pretty_slug, filename])
                 try:
                     file = PageFile.objects.get(slug__exact=page.slug,
                                                 name__exact=filename)
                     cls = ' class="file_%s"' % file.rough_type
                 except PageFile.DoesNotExist:
                     cls = ' class="missing_link"'
             elif unquote_plus(url).startswith('tags/'):
                 cls = ' class="tag_link"'
             else:
                 try:
                     page = Page.objects.get(slug__exact=slugify(url))
                     url = reverse('pages:show', args=[page.pretty_slug])
                 except Page.DoesNotExist:
                     # Check if Redirect exists.
                     if not Redirect.objects.filter(source=slugify(url)):
                         cls = ' class="missing_link"'
                     # Convert to proper URL: My%20page -> My_page
                     url = name_to_url(url_to_name(url))
                     url = reverse('pages:show', args=[url])
         return '<a href="%s"%s>%s</a>' % (url, cls,
                                           self.nodelist.render(context))
     except:
         return ''
Example #6
0
 def get_object(self, request, slug="", file=""):
     obj = PageFile(slug=slugify(slug), name=file)
     page = Page(slug=slugify(slug))
     obj.page = page.versions.most_recent()
     obj.title = _('File %(filename)=s on page "%(pagename)s"') % {
         "filename": obj.name,
         "pagename": obj.pageobj.name,
     }
     return obj
Example #7
0
 def get_redirect_url(self, **kwargs):
     pagename = self.request.GET.get('pagename')
     if not pagename.strip():
         # No page name provided, so let's return a useful error message.
         messages.add_message(self.request, messages.SUCCESS,
             _('You must provide a page name when creating a page.'))
         return reverse('haystack_search')
     if Page.objects.filter(slug=slugify(pagename)):
         return Page.objects.get(slug=slugify(pagename)).get_absolute_url()
     else:
         return reverse('pages:edit', args=[pagename])
Example #8
0
 def get_redirect_url(self, **kwargs):
     pagename = self.request.GET.get('pagename')
     if not pagename.strip():
         # No page name provided, so let's return a useful error message.
         messages.add_message(
             self.request, messages.SUCCESS,
             _('You must provide a page name when creating a page.'))
         return reverse('haystack_search')
     if Page.objects.filter(slug=slugify(pagename)):
         return Page.objects.get(slug=slugify(pagename)).get_absolute_url()
     else:
         return reverse('pages:edit', args=[pagename])
    def get_cache_key(*args, **kwargs):
        from django.core.urlresolvers import get_urlconf
        from pages.models import name_to_url

        slug = kwargs.get('slug')
        # Control characters and whitespace not allowed in memcached keys
        return 'globaltags:%s' % slugify(slug).replace(' ', '_')
Example #10
0
    def get_object(self, request, region='', slug=''):
        self.setup_region(region)

        obj = Page(slug=slugify(slug), region=self.region)
        obj.title = obj.versions.most_recent().name
        obj.page = obj
        return obj
    def get_object(self, request, region='', slug=''):
        self.setup_region(region)

        obj = Page(slug=slugify(slug), region=self.region)
        obj.title = obj.versions.most_recent().name
        obj.page = obj
        return obj
Example #12
0
 def form_valid(self, form):
     try:
         p = Page.objects.get(slug=slugify(self.kwargs['slug']))
         self.new_pagename = form.cleaned_data['pagename']
         p.rename_to(self.new_pagename)
     except PageExistsError, s:
         messages.add_message(self.request, messages.SUCCESS, s)
         return HttpResponseRedirect(reverse('pages:show', args=[p.slug]))
Example #13
0
 def form_valid(self, form):
     try:
         p = Page.objects.get(slug=slugify(self.kwargs['slug']))
         self.new_pagename = form.cleaned_data['pagename']
         p.rename_to(self.new_pagename)
     except PageExistsError, s:
         messages.add_message(self.request, messages.SUCCESS, s)
         return HttpResponseRedirect(reverse('pages:show', args=[p.slug]))
    def get_cache_key(*args, **kwargs):
        from django.core.urlresolvers import get_urlconf
        from pages.models import name_to_url

        urlconf = get_urlconf() or settings.ROOT_URLCONF
        slug = kwargs.get('slug')
        region = CacheMixin.get_region_slug_param(*args, **kwargs)
        # Control characters and whitespace not allowed in memcached keys
        return 'tags:%s/%s/%s' % (urlconf, name_to_url(region), slugify(slug).replace(' ', '_'))
Example #15
0
 def get_queryset(self):
     self.tag_name = slugify(self.kwargs["slug"])
     try:
         self.tag = Tag.objects.get(slug=self.tag_name)
         self.tag_name = self.tag.name
         return PageTagSet.objects.filter(tags=self.tag)
     except Tag.DoesNotExist:
         self.tag = None
         return PageTagSet.objects.none()
Example #16
0
 def get_queryset(self):
     self.tag_name = slugify(self.kwargs['slug'])
     try:
         self.tag = Tag.objects.get(slug=self.tag_name)
         self.tag_name = self.tag.name
         return PageTagSet.objects.filter(tags=self.tag)
     except Tag.DoesNotExist:
         self.tag = None
         return PageTagSet.objects.none()
Example #17
0
 def build_redirect_url(self, entity, model):
     "method to build redirect url after successful post"
     if model == 'product':
         redirect_url = '/products/%s/%s' % (str(
             entity.key().id()), models.slugify(entity.title))
     elif model == 'page':
         redirect_url = entity.url
     else:
         redirect_url = '/admin/home?item=%ss' % (model)
     return redirect_url
def suggest_tags(request):
    """
    Simple tag suggest.
    """
    def _make_unique(l):
        d = {}
        ll = []
        for m in l:
            if m['slug'] in d:
                continue
            ll.append(m) 
            d[m['slug']] = True
        return ll

    # XXX TODO: Break this out when doing the API work.
    import json

    term = request.GET.get('term', None)
    if not term:
        return HttpResponse('')
    region_id = request.GET.get('region_id', None)
    if region_id is not None:
        results = Tag.objects.filter(
            slug__startswith=slugify(term),
            region__id=int(region_id)).exclude(pagetagset=None)

        if len(results) < 5:
            # Set a sane limit before adding
            results = results.values('slug').distinct().values('slug', 'name').order_by('slug')[:20]
            global_results = Tag.objects.filter(
                slug__startswith=slugify(term)).exclude(pagetagset=None).values('slug').distinct().values('slug', 'name').order_by('slug')[:20]
            results = _make_unique(list(results) + list(global_results))[:20]
        else:
            results = results.values('slug').distinct().values('slug', 'name').order_by('slug')[:20]

    else:
        results = Tag.objects.filter(
            slug__startswith=slugify(term)).exclude(pagetagset=None).values('slug').distinct().values('slug', 'name').order_by('slug')[:20]

    results = [t['name'] for t in results]
    return HttpResponse(json.dumps(results))
Example #19
0
def create_post():
    if request.method == 'POST':
        try:
            title = request.form.get('title')
            body = request.form.get('body')
            author = current_user.login
            p = Post(title=title, body=body, author=author)
            db.session.add(p)
            db.session.commit()
        except Exception:
            raise (Exception)

        photos = request.form.get('files')
        photos = json.loads(photos)

        for photo in photos:
            if allowed_file(photo['name']):
                img = Photos(link='static/images/' +
                             slugify(str(p.created), '') + photo['name'],
                             post_id=p.id)
                db.session.add(img)
                db.session.commit()
                image_data = re.sub('^data:image/.+;base64,', '',
                                    photo['dataURL'])
                image = Image.open(
                    io.BytesIO(base64.decodebytes(image_data.encode())))
                image.save(
                    UPLOAD_FOLDER + '/' + slugify(str(p.created), '') +
                    photo['name'], 'JPEG')

    last_post = Post.query.order_by(Post.id.desc()).first()
    last_alert = Alert.query.order_by(Alert.id.desc()).first()

    return render_template('create_post.html',
                           last_post=last_post,
                           last_alert=last_alert,
                           weekDays=rusWeekDays,
                           months=rusMonths)
Example #20
0
def edit_post(slug):
    post = Post.query.filter(Post.slug == slug).first_or_404()

    if request.method == 'POST':
        form = PostForm(fromdata=request.form, obj=post)
        post.title = request.form['title']
        post.body = request.form['body']
        post.slug = slugify(post.title)
        db.session.commit()
        form.populate_obj(post)

        return redirect(url_for('posts.post_detail', slug=post.slug))

    form = PostForm(obj=post)
    return render_template('posts/edit_post.html', post=post, form=form)
Example #21
0
def create_alert():
    if request.method == 'POST':
        body = request.form.get('body')
        file = request.files['file']
        alert = Alert(body=body, author=current_user.login)
        db.session.add(alert)
        db.session.commit()
        photo = Photos(link=(UPLOAD_FOLDER + '/' +
                             slugify(str(alert.created), '') + file.filename),
                       alert_id=alert.id)
        db.session.add(photo)
        db.session.commit()
        file.save(
            os.path.join(UPLOAD_FOLDER,
                         slugify(str(alert.created), '') + file.filename))

    last_post = Post.query.order_by(Post.id.desc()).first()
    last_alert = Alert.query.order_by(Alert.id.desc()).first()

    return render_template('create_alert.html',
                           last_post=last_post,
                           last_alert=last_alert,
                           weekDays=rusWeekDays,
                           months=rusMonths)
 def get_queryset(self):
     self.tag_name = slugify(self.kwargs['slug'])
     try:
         region = self.get_region()
         self.tag = Tag.objects.get(
             slug=self.tag_name, region=region)
         self.tag_name = self.tag.name
         pts = PageTagSet.objects.filter(tags=self.tag, region=region).\
             select_related('page', 'region').defer('page__content')
         if not pts.exists():
             raise Http404
         return pts
     except Tag.DoesNotExist:
         self.tag = None
         raise Http404
Example #23
0
def validate_league_name(form, field):
  """Validate the league name."""
  current_league_id = form.data['id']
  current_league_name = None
  if current_league_id:
    current_league = models.League.get_by_id(int(current_league_id))
    current_league_name = current_league.name

  league_name = field.data.strip()

  if not league_name:
    raise validators.ValidationError('No league name specified.')

  else:
    # Only throw a name already exists error, if the user is trying to
    # create a league or change their league name.
    if ((league_name != current_league_name) and
         models.League.get_by_name(models.slugify(league_name))):
      raise validators.ValidationError('League name already exists.')
Example #24
0
 def post(self, file_type, product_key):
     "Create a new file."
     if users.is_current_user_admin():
         product = models.Product.get(product_key)
         if product:
             data = self.request.POST.get(
                 'data').file.read()  #collect file data
             #if file data exists add it to the product
             if data:
                 file_type = self.request.get('file_type')
                 content_type = self.request.get('content_type')
                 try:
                     file = models.FileData(data=data)
                     file.put()  #put the actual data
                     product_file = models.ProductFile(
                         file=file,
                         content_type=content_type,
                         file_type=file_type,
                         product=product)
                     product_file.put()
                 except:
                     print 'upload failed, try again.'
                     return
                 product.files.append(
                     product_file.key())  #add to file key list
                 product.files = product.verify_file_list()
                 product.put()
                 if self.request.get('xhr'):
                     self.generate('templates/upload.html', {
                         'product': product,
                         'product_file': product_file,
                     })
                 else:
                     self.redirect('/products/%s/%s' %
                                   (product.key().id(),
                                    models.slugify(product.title)))
                 return
             else:
                 print 'No file uploaded'
         else:
             print 'No product found'
     else:
         self.generate_error(403)
Example #25
0
 def get_redirect_url(self, **kwargs):
     pagename = self.request.GET.get('pagename')
     if Page.objects.filter(slug=slugify(pagename)):
         return Page.objects.get(slug=slugify(pagename)).get_absolute_url()
     else:
         return reverse('pages:edit', args=[pagename])
Example #26
0
 def get_object(self, request, slug='', file=''):
     obj = PageFile(slug=slugify(slug), name=file)
     page = Page(slug=slugify(slug))
     obj.page = page.versions.most_recent()
     obj.title = 'File %s on page "%s"' % (obj.name, obj.page.name)
     return obj
Example #27
0
 def get_object(self, request, slug):
     obj = Page(slug=slugify(slug))
     obj.title = obj.versions.most_recent().name
     obj.page = obj
     return obj
Example #28
0
 def wrapped(*args, **kwargs):
     if "slug" in kwargs:
         kwargs["original_slug"] = kwargs["slug"]
         kwargs["slug"] = models.slugify(kwargs["slug"])
     return func(*args, **kwargs)
Example #29
0
 def wrapped(*args, **kwargs):
     if 'slug' in kwargs:
         kwargs['original_slug'] = kwargs['slug']
         kwargs['slug'] = models.slugify(kwargs['slug'])
     return func(*args, **kwargs)
Example #30
0
    def post(self, verb, team_slug):
        assert (verb in ["new", "toggle", "join", "decline", "leave"]), "POST verb is not supported: %s" % `verb`
        user = users.get_current_user()
        profile = models.Profile.get_by_key_name(user.user_id())
        
        if verb == "new":
            # if user is creating a new team...
            team_name = self.request.get('newteamname')
            emails_to_invite = self.request.get('colleagues')
            logging.info(emails_to_invite)
            list_of_emails = [l.strip() for l in emails_to_invite.split(',')]
            logging.info(list_of_emails)
            if team_name not in [None, '', ' ']:
                # see if team already exists
                team = models.Team.find_by_name(team_name)
                if team is not None:
                    memberships_teams_keys = [m.team.key() for m in profile.membership_set]
                    # don't allow user to invite others to the team
                    # if they are not a member of the team
                    if team.key() not in memberships_teams_keys:
                        self.response.out.write("Oops. That team name is already taken.")
                        return
                if team is None:
                    # create new team
                    team = models.Team(name=team_name)
                    # make a slug from the supplied team name
                    team.slug = models.slugify(team_name)
                    team.put()
                    # create a new membership for the user
                    membership = models.Membership(team=team, profile=profile)
                    membership.put()
                for email in list_of_emails:
                    logging.info(email)
                    invite = models.Invitation.invite_colleague(team,\
                        profile, email)
                    logging.info(invite)

                self.response.out.write("Invitations sent for team '%s'" % team.name)

        # TODO get rid of toggle in favor of "leave"
        if verb == "toggle":
            # get the user's team memberships
            memberships = profile.membership_set
            # get a list of keys of the teams user has membership in
            memberships_teams_keys = [m.team.key() for m in memberships]

            team_slug = self.request.get('teamslug')
            team = models.Team.find_by_slug(team_slug)
            if team.key() not in memberships_teams_keys:
                new_member = models.Membership(team=team, profile=profile)
                new_member.put()
                self.response.out.write("You are now a member of %s" % team.name)
            else:
                if team.key() in memberships_teams_keys:
                    old_membership = models.Membership.find_by_profile_and_team(profile, team)
                    if old_membership is not None:
                        old_membership.delete()
                        self.response.out.write("You are no longer a member of %s" % team.name)

        if verb in ["join", "decline"]:
            # get the user's invitations
            invitations = profile.pending_invitation_set
            if invitations is None:
                self.response.out.write("Oops. Can't find any pending invitations.")
            else:
                invitations_teams_keys = [i.team.key() for i in invitations]

            # get the user's team memberships
            memberships = profile.membership_set
            # get a list of keys of the teams user has membership in
            memberships_teams_keys = [m.team.key() for m in memberships]

            invitation = models.Invitation.get(self.request.get('invitekey'))
            if invitation is not None:
                team = invitation.team
                if team.key() not in memberships_teams_keys:
                    if team.key() in invitations_teams_keys:
                        if verb == "join":
                            new_member = models.Membership(team=team, profile=profile)
                            new_member.put()
                            #self.response.out.write("You are now a member of %s" % team.name)
                            self.redirect("/team/show/%s" % team.slug)
                        else:
                            self.response.out.write("You declined invitation to %s" % team.name)
                            # TODO sidebar should be reloaded to get rid of accept/decline links
                        invitation.delete()
                    else:
                        self.response.out.write("Oops. Can't find a pending invitation for %s" % team.name)
                else:
                    self.response.out.write("Oops. You are already a member of %s" % team.name)
Example #31
0
 def wrapped(*args, **kwargs):
     if 'slug' in kwargs:
         kwargs['original_slug'] = kwargs['slug']
         kwargs['slug'] = models.slugify(kwargs['slug'])
     return func(*args, **kwargs)
 def get_object(self):
     from pages.models import slugify
     p = Page.objects.filter(slug=slugify(self.request.POST['page_name']), region=self.get_region())
     if p.exists():
         return p[0]
Example #33
0
    def get(self, product_id, product_title):
        template_values = memcache.get(str(product_id), namespace='products')
        if not template_values:
            try:
                product_id = int(product_id)
            except:
                self.generate_error(404)
                return
            product = models.Product.get_by_id(product_id)
            if not product:
                self.generate_error(404)
                return
            #retrieve files and images so that they can be stored in the memcache too
            all_files = models.ProductFile.get(product.files)
            pay_files = []
            free_files = []
            image_files = []
            for file in all_files:
                if file.content_type == 'pay': pay_files.append(file)
                elif file.content_type == 'free': free_files.append(file)
                else: image_files.append(file)
            template_values = {
                'all_files': all_files,
                'data': product,
                'file_types': settings.PAY_FILE_TYPES,
                'free_files': free_files,
                'image_files': image_files,
                'page_title': product.title,
                'pay_files': pay_files,
                'purchase_days': settings.PURCHASE_DAYS,
            }

            try:
                memcache.add(str(product_id),
                             template_values,
                             namespace='products')
            except:
                pass
        else:
            product = template_values['data']
        #make sure the product page title is the same as the title in the datastore
        if not str(product_title) == models.slugify(product.title):
            self.generate_error(404)
            return
        if not product.active and not self.template_values[
                'admin']:  #only admin can see non-active
            self.generate_error(404)
            return
        if not self.template_values['admin']:  #increase page view counter
            try:
                memcache.incr(str(product_id),
                              namespace='counters',
                              initial_value=0)
            except:
                pass
        self.template_values.update(template_values)
        if not self.template_values['admin'] and self.session:
            product = self.template_values[
                'data']  #get product to test if purchased
            is_product_purchased = self.session.is_product_purchased(
                product.key())
            self.template_values.update(
                {'is_product_purchased': is_product_purchased})
        else:
            self.template_values.update(
                {'file_types_dict':
                 settings.FILE_TYPES})  #for upload in admin view
        self.generate('templates/view.html', {})
 def get_queryset(self):
     self.tag_name = slugify(self.kwargs['slug'])
     return PageTagSet.objects.filter(tags__slug=self.tag_name).select_related('page', 'region').defer('page__content')
Example #35
0
    def post(self):
        if self.template_values['admin']:
            action = self.request.get('action')
            model = self.request.get('item')
            id = self.request.get(
                'id')  #entity id for purchases and title for pages
            post_url = self.build_post_url(action, model, id)
            if action == 'new':
                entity = False
                page_title = 'New ' + model.capitalize()
                data = self.model_form_dict[model](data=self.request.POST)
            else:
                entity = self.get_entity(model, id)
                if not entity:
                    self.generate_error(404)
                    return
                if model == 'product':
                    old_tag_list = entity.tags  #keep copy of old tags
                    original_product_status = entity.active  #keep copy of original active status
                    original_title = entity.title
                if not action:
                    page_title = 'Edit'
                    data = self.model_form_dict[model](data=self.request.POST,
                                                       instance=entity)
                elif action == 'delete':
                    redirect_url = '/admin/home?item=%ss' % (model)
                    if model == 'product':  #make sure entity is not purchased before deleting
                        is_entity_purchased = entity.is_entity_purchased()
                        if is_entity_purchased:
                            redirect_url = '/edit?action=delete&item=product&id=%s' % str(
                                entity.key().id())
                            self.redirect(redirect_url +
                                          '&errors=product_purchased')
                            return
                        else:
                            models.update_popular_products()
                    entity.delete()
                    self.redirect(redirect_url)
                    return
                else:
                    self.generate_error(400)
                    return

            data_valid = data.is_valid()
            if data_valid:  #check the to make sure the data is valid
                entity = data.save(commit=False)
                if model == 'product':
                    product_tags = self.request.POST.get('tags')
                    new_tag_list = models.Tag.clean_tags(product_tags, ',')
                    entity.tags = new_tag_list
                elif model == 'page':  # for pages slugify the title for the url
                    entity.url = '%s' % (models.slugify(entity.title))
                elif model == 'purchase':  #for purchases
                    product_id_add_list = self.request.get_all('product_ids')
                    email = entity.purchase_email
                    user = models.User().all().filter('email =', email).get()
                    if user:
                        user.delete_sessions(
                        )  #delete current user session, so purchases get updated
                        entity.user = user
                    if action == "new":
                        key_name = models.generate_purchase_key()
                        entity.purchase_id = int(key_name.split('-')[0])
                        entity = models.Purchase(
                            key_name=key_name,
                            **dict([(prop, getattr(entity, prop))
                                    for prop in models.Purchase.properties()]))
                entity.put()
                if model == 'product':
                    need_update_popular_products = False
                    try:
                        entity.index()
                    except:
                        print 'indexing failed - at least one tag is required'
                    if action == 'new':
                        old_tag_list = []  #no tags for new product
                        need_update_popular_products = True
                    else:
                        if not entity.active == original_product_status or not entity.title == original_title:
                            need_update_popular_products = True
                    if not new_tag_list == old_tag_list:
                        models.Tag.update_tags(new_tag_list, old_tag_list,
                                               entity)
                        need_update_popular_products = True
                    if need_update_popular_products:
                        models.update_popular_products()
                elif model == 'purchase':
                    if product_id_add_list:
                        entity.admin_add_purchase_items(
                            entity.charge_date, product_id_add_list, user,
                            entity.total_charge_amount)
                self.redirect(self.build_redirect_url(entity, model))

            else:
                template = 'templates/edit.html'
                self.generate_edit_form(data,
                                        model,
                                        page_title,
                                        post_url,
                                        template,
                                        entity=entity)
 def handler404(self, request, *args, **kwargs):
     tag_name = slugify(kwargs['slug'])
     msg = (_('<p>No pages tagged "%s".</p>') % 
          tag_name)
     html = render_to_string('404.html', {'message': msg}, RequestContext(request))
     return HttpResponseNotFound(html)
Example #37
0
 def file_name(self, req, obj):
   return '%s-screenshot-%s' % (
     models.slugify(obj.question.get().answer_title), obj.key.id())
Example #38
0
 def get_context_data(self, **kwargs):
     context = super(PageRenameView, self).get_context_data(**kwargs)
     context['page'] = Page.objects.get(slug=slugify(self.kwargs['slug']))
     return context
Example #39
0
 def get_object(self, request, slug):
     obj = Page(slug=slugify(slug))
     obj.title = obj.versions.most_recent().name
     obj.page = obj
     return obj
Example #40
0
 def get_redirect_url(self, **kwargs):
     pagename = self.request.GET.get('pagename')
     if Page.objects.filter(slug=slugify(pagename)):
         return Page.objects.get(slug=slugify(pagename)).get_absolute_url()
     else:
         return reverse('pages:edit', args=[pagename])
Example #41
0
 def get_object(self, request, slug='', file=''):
     obj = PageFile(slug=slugify(slug), name=file)
     page = Page(slug=slugify(slug))
     obj.page = page.versions.most_recent()
     obj.title = 'File %s on page "%s"' % (obj.name, obj.page.name)
     return obj
Example #42
0
 def get_context_data(self, **kwargs):
     context = super(PageRenameView, self).get_context_data(**kwargs)
     context['page'] = Page.objects.get(slug=slugify(self.kwargs['slug']))
     return context
Example #43
0
 def file_name(self, req, obj):
   return '%s-packshot-%s' % (models.slugify(obj.answer_title), obj.key.id())