Example #1
0
 def move(self, request):
     import logging
     logging.error(request.POST)
     page = get_object_or_404(Page, request.POST['page_id'])
     target = get_object_or_404(Page, request.POST['target_id'])
     position = request.POST['position']
     if position == 'inside':
         page.parent_page = target
     elif position == 'before':
         prev = target.previous_sibling()
         if prev:
             page.order = (target.order + prev.order) / 2
         else:
             page.order = target.order / 2
         page.parent_page = target.parent_page
     elif position == 'after':
         next = target.next_sibling()
         if next:
             page.order = (target.order + next.order) / 2
         else:
             page.order = target.order + 1000
         page.parent_page = target.parent_page
     else:
         raise ValueError("Incorrect position parameter")
     page.put()
     
     return HttpResponse('ok')
Example #2
0
def getCachedObjectOr404(model = None,key=None,key_name=None,id = None , id_or_name = None):
    """
    Get a object from cache. If it is not existed in the cache, 
    it will query from database directly and save it in cache.

    If the object is not existed in the cache and database , it 
    will raise Http404 exception
    """

    if id_or_name:
        try:
            id = int(id_or_name)
        except ValueError:
            key_name = id_or_name

    cache_key = getCacheObjectKey(model = model , key=key , key_name = key_name,id = id)
    
    #print cache_key
    object = memcache.get(cache_key)

    if object == None:
        if key:
            object = get_object_or_404(model,key)
        else:
            object = get_object_or_404(model,key_name=key_name, id = id)
        if not memcache.add(cache_key, object, _default_cache_time):
            logging.error("Memcache set %s failed." % cache_key)

    return object
Example #3
0
def station_by_city_get(request, cityId, stationId):
  city = get_object_or_404(City, id=int(cityId))
  station = get_object_or_404(BikeStation, id=int(stationId))
  if station.providerRef.cityRef != city:
    raise Http404
  doc = utils.object_to_xml(station)
  return HttpResponse(doc.toxml(), content_type="text/xml")
Example #4
0
def status_by_station_get(request, cityId, stationId):#ask about it
  city = get_object_or_404(City, id=int(cityId))
  station = get_object_or_404(BikeStation, id=int(stationId))
  if station.city != city:
    raise Http404
  status = station.bikestationstatus_set.get()
  doc = utils.object_to_xml(status)
  return HttpResponse(doc.toxml(), content_type="text/xml")
Example #5
0
def version_diff(request, slug, version1, version2):
    if int(version1) == 0:
        old_content = ''
    else:
        old_content = get_object_or_404(Page, key_name="page%s%s" % (slug, version1)).content
    page = get_object_or_404(Page, key_name="page%s%s" % (slug, version2))
    diff = easy_diff(old_content, page.content)
    return render_to_response('wiki/version_diff.html', {'diff': diff, 'slug': slug, 'version1': version1, 'version2': version2, 'page': page})
Example #6
0
def edit(request,kind,object_id):
    """
    Edit model
    """

    (model,model_form) = _getModelInfo(kind)

    message = ""

    id = None
    key_name = None
    try:
        id = int(object_id)
    except ValueError:
        key_name = object_id

    object = get_object_or_404(model,key_name = key_name , id=id)

    if request.method == 'POST':
        form = model_form(request.POST,instance=object)
        if form.is_valid():
            
            #Old object was changed by the from, so it need to get a new copy
            object = get_object_or_404(model,key_name = key_name , id=id)
            new_object = form.save(commit = False)
            
            changelog = createChangelog(object,new_object,form.cleaned_data['log_message'])
            if changelog:                
            
                db.put([new_object,changelog])
                updateCachedObject(new_object)
                #TODO - Update loader cache
                
                return HttpResponseRedirect(new_object.get_absolute_url())
            else:
                message = _("Nothing changed. The form will not be saved")

    else:
        form = model_form(instance=object)

    view_object_link = None
    if object : 
        view_object_link = object.get_absolute_url()
        
    return render_to_response( 
        request,
        'gogogo/db/edit.html'
        ,{ "form" : form , 
           "object" : object,
           "kind" : kind,
           "message" : message,
           "history_link" : _reverse('gogogo.views.db.changelog.list') + "?kind=%s" % kind,
           "view_object_link" : view_object_link,
           "action" : _reverse('gogogo.views.db.edit',args=[kind,object_id]) ,
           })		
Example #7
0
def download_file(request, key, name):
    file = get_object_or_404(File, key)
    if file.name != name:
        raise Http404('Could not find file with this name!')
    return HttpResponse(file.file,
                        content_type=guess_type(file.name)[0]
                        or 'application/octet-stream')
Example #8
0
def render_image(request, image_key):
    """
    Serves image data. 
    """
    img = get_object_or_404(Image, image_key)
    #TODO[Alex Tereshkin|2009-09-23]: mime types
    return HttpResponse(img.data)
Example #9
0
 def history_view(self, request, object_id, extra_context=None):
     "The 'history' admin view for this model."
     from django.contrib.admin.models import LogEntry
     model = self.model
     opts = model._meta
     app_label = opts.app_label
     action_list = LogEntry.all().filter('object_id =', object_id).filter(
         'content_type =', ContentType.objects.get_for_model(model).id
     ).order('action_time').fetch(301)
     # If no history was found, see whether this object even exists.
     obj = get_object_or_404(model, object_id)
     context = {
         'title': _('Change history: %s') % force_unicode(obj),
         'action_list': action_list,
         'module_name': capfirst(force_unicode(opts.verbose_name_plural)),
         'object': obj,
         'root_path': self.admin_site.root_path,
         'app_label': app_label,
     }
     context.update(extra_context or {})
     return render_to_response(self.object_history_template or [
         "admin/%s/%s/object_history.html" % (app_label, opts.object_name.lower()),
         "admin/%s/object_history.html" % app_label,
         "admin/object_history.html"
     ], context, context_instance=template.RequestContext(request))
Example #10
0
def invite_friends_for_event(request, key_id):
    from cgi import escape

    key_id = int(key_id, 10)
    event = get_object_or_404(Event, id=key_id)

    # This owuld be external link, but we want it to open inside the app.
    # event_show_url = "http://%s%s?invitation=1"%(request.META['HTTP_HOST'], event.get_facebook_url())
    event_show_url = get_facebook_app_url(event.get_facebook_url()) + '?invitation=' + str(request.facebook.uid)

    content = """<fb:name uid="%s" firstnameonly="true" shownetwork="false"/>
       wants to let you know about Art of Living event: <a href="%s">%s</a>,
       <fb:req-choice url="%s" label="Check out this event"/>
       """ % (request.facebook.uid, event_show_url, event, event_show_url)

    invitation_content = escape(content, True)
    if request.GET.has_key('next'):
        next = request.GET['next']
    else:
        next = "http://" + request.META['HTTP_HOST'] + event.get_facebook_url() + '?invitation=' + str(request.facebook.uid)

# FIXME: Why next doesnt work correctly in real life? Do I need to encode it?

    return render_to_response(request, 'invite_for_event.html',
                              {'content':invitation_content, 'event':event, 'next':escape(next), 'in_iframe' : True} )
Example #11
0
 def user_change_password(self, request, id):
     if not request.user.has_perm('auth.change_user'):
         raise PermissionDenied
     user = get_object_or_404(self.model, id)
     if request.method == 'POST':
         form = self.change_password_form(user, request.POST)
         if form.is_valid():
             new_user = form.save()
             msg = ugettext('Password changed successfully.')
             Message(user=request.user, message=msg).put()
             return HttpResponseRedirect('..')
     else:
         form = self.change_password_form(user)
     return render_to_response('admin/auth/user/change_password.html', {
         'title': _('Change password: %s') % escape(user.username),
         'form': form,
         'is_popup': '_popup' in request.REQUEST,
         'add': True,
         'change': False,
         'has_delete_permission': False,
         'has_change_permission': True,
         'has_absolute_url': False,
         'opts': self.model._meta,
         'original': user,
         'save_as': False,
         'show_save': True,
         'root_path': self.admin_site.root_path,
     }, context_instance=RequestContext(request))
Example #12
0
def download_file(request, key, name):
    file = get_object_or_404(File, key)
    if file.name != name:
        raise Http404('Could not find file with this name!')
    return HttpResponse(
        file.file,
        content_type=guess_type(file.name)[0] or 'application/octet-stream')
Example #13
0
def cmspage(request, url):
    if not url.endswith("/") and settings.APPEND_SLASH:
        return HttpResponseRedirect("%s/" % request.path)
    if not url.startswith("/"):
        url = "/" + url
    f = get_object_or_404(Page, "url =", url)

    return render_page(request, f)
Example #14
0
def detail(request, key_id):
    reminder = get_object_or_404(Reminder, id=int(key_id))
    reminder_form = ReminderForm(request.POST or None, instance=reminder)
    if reminder_form.is_valid():
        reminder_form.save()
        Message(message='<p class="success message">%s</p>' %
                "Your changes were saved successfully.",
                user=request.user).put()
    return render_to_response(request, 'reminders/detail.html', locals())
Example #15
0
def delete_albumentry(request,key):
    userfile = get_object_or_404(UserFile,key)
    if userfile.author==users.get_current_user() or users.is_current_user_admin():
        userfile.delete()
        #flush cache in order to update the file list
        memcache.flush_all()
        return HttpResponseRedirect(reverse(albumentry))
    else:
        return HttpResponseForbidden()
Example #16
0
def show_albumentry(request,key):
    userfile = get_object_or_404(UserFile,key)
#    if userfile.icon:
#        return show_icon(request,key)
    
    filebin=userfile.filebin_set.get()
    if not userfile or not filebin:        
        return HttpResponseNotFound()
    return HttpResponse(filebin.bin,'image/JPEG')      
Example #17
0
def statuses_by_provider_get(request, providerId):
  provider = get_object_or_404(Provider, id=int(providerId))
  statuses = []
  for station in provider.bikestation_set:
    station_status = station.status
    if station_status:
      statuses.append(station_status)
  doc = utils.object_to_xml(statuses, "stationStatuses")
  return HttpResponse(doc.toxml(), content_type="text/xml")  
Example #18
0
def change_entity(request, key, form_class):
    instance = get_object_or_404(form_class.Meta.model, key)
    if request.method == "POST":
        form = form_class(request.POST, instance=instance)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse("dashboard"))
    else:
        form = form_class(instance=instance)
    return render_to_response(request, "teammail/change_entity.html", data={"form": form})
Example #19
0
def view_event_show(request, key_id):
    key_id = int(key_id, 10)
    if request.user.is_authenticated():
        event = get_object_or_404(Event, id=key_id)
        fav = Favourite.all().filter("event =", event).filter("user ="******"is_fav": fav}
    return object_detail(request, Event.all(), object_id=key_id, extra_context=extra_context)
Example #20
0
def detail_quiz(request, key):
    list_questions = get_object_or_404(Quiz, key).questions
    quiz = []
    if list_questions != None:
        for key_question in list_questions:
            item = {}
            answers = []
            question = get_object_or_404(Question, key_question)
            item['question'] = question
            for key_answer in question.answers:
                answer = get_object_or_404(Answer, key_answer)
                answers.append(answer)
            item['answers'] = answers
            quiz.append(item)
    return object_detail(request,
                         Quiz.all(),
                         key,
                         extra_context={
                             'quiz': quiz,
                             'result': False
                         })
Example #21
0
File: views.py Project: ryuic/newsy
def entry_list(request, key=None, show=None):
    payload = {'key': key}
    entries = Entry.all()
    if key:
        feed = get_object_or_404(Feed, key)
        payload['feed'] = feed
        entries.filter('feed_ref =', feed)
    if show:
        entries.filter('cat_ref =', None)
    entries.order('-created_at')

    return object_list(request, entries, paginate_by=25, extra_context=payload)
Example #22
0
def show_animal_by_name(request, category, year, month, day, name):
    date_ = datetime.date(int(year), int(month), int(day))
    name = urllib.unquote_plus(name)
    a = animal = get_object_or_404(Animal, 'brought_to_shelter =', date_,
                                   'category =', category, 'name = ',
                                   name)  # todo: also check date
    return render_to_response(request,
                              "nebhs/animal_detail.html",
                              data={
                                  'object': animal,
                                  'page_title': _animal_page_title(animal),
                                  'template_wrapper': 'section-adoptions.html'
                              })
Example #23
0
def show_animal_by_id(request, category, id):
    a = animal = get_object_or_404(Animal, 'category =', category, 'code = ',
                                   id)  # todo: also check date
    return render_to_response(
        request,
        "nebhs/animal_detail.html",
        data={
            'object': animal,
            'page_title': _animal_page_title(animal),
            'template_wrapper': 'section-adoptions.html'
        }
    )  #Adoptable {{ object.category|capfirst }}: {{ object.name|capfirst }}
    pass
Example #24
0
def upload_image(request, page_key, plugin_name):
    """
    A view for Ajax image upload.
    """
    page = get_object_or_404(Page, page_key)
    if request.method == "POST":
        img = Image()
        img.data = request.FILES['value'].read()
        img.put()
        setattr(page.storage, plugin_name, img.key())
        page.put()

    plugin = ImagePlugin(plugin_name, page)
    return HttpResponse(plugin.render())
Example #25
0
def put(request, public_key, secret_key):
	account = get_object_or_404(Account, 'public_key =', public_key, 'secret_key =', secret_key)
	request_file = request.FILES['myfile']
	file = File(
		name = request_file.name,
		data = request_file.read(),
		owner = account,
		added_date = datetime.now(),
		size = request_file.size
	)
	
	file.put()
	
	return HttpResponse(file.key())
Example #26
0
def albumentry(request):
    if request.method == 'POST':
        if 'file' in request.FILES:
            file = request.FILES['file']
            userfile = UserFile(  mimetype=request.META['CONTENT_TYPE'],
                                    author = users.get_current_user(),
                                    size = file.size,
                                    name=file.name,
                                    comment=request.REQUEST.get('comment',''))
            bin=file.read()
            try:
                userfile.icon=images.resize(bin, width=60)
            except:
                pass
                
            userfile.save() 
            filebin = FileBin(userfile=userfile, bin=db.Blob(bin))
            filebin.save()
            file.close()
            if UserFile.all().count() > FILE_MAX:
                oldest_file = UserFile.all().order('-creationDate').get()
                oldest_file.delete()
            #flush cache in order to update the file list
            memcache.flush_all()
            return HttpResponseRedirect(reverse(albumentry))
        else:
            return HttpResponseRedirect(reverse(albumentry))

    else:
        filelist = UserFile.all().order('-creationDate').fetch(FILE_MAX)
        user = users.get_current_user()
        if user:
            sign_link = '<a href="%s">Logout</a>' % users.create_logout_url(reverse(albumentry))
        else:
            sign_link = '<a href="%s">Login</a>' % users.create_login_url(reverse(albumentry))
        displayFile=None
        if 'key' in request.REQUEST:
            displayFile=get_object_or_404(UserFile,request.REQUEST['key'])     
            
        email_form=EmailForm()       
        template_values = {
            'displayFile':displayFile,               
#            'user': user,
            'sign_link': sign_link,
            'filelist': filelist,
            'form':FileForm(),
            'email_form':email_form,
        }
        return render_to_response('upload/show_albumentry.html',template_values,context_instance=RequestContext(request))
Example #27
0
def result_quiz(request, key):
    if request.method == 'POST':
        quiz = []
        list_questions = get_object_or_404(Quiz, key).questions
        if list_questions != None:
            i = 0
            note = 0
            for key_question in list_questions:
                i += 1
                item = {}
                answers = []
                question = get_object_or_404(Question, key_question)
                item['question'] = question
                form_response = request.POST['%s' % question.key()]
                good_response = '%s' % question.question_answer.key()
                if form_response == good_response:
                    item['point'] = True
                    note += 1
                else:
                    item['point'] = False

                for key_answer in question.answers:
                    answer = get_object_or_404(Answer, key_answer)
                    if answer == question.question_answer:
                        answers.append(answer)
                    item['answers'] = answers
                quiz.append(item)
    return object_detail(request,
                         Quiz.all(),
                         key,
                         extra_context={
                             'quiz': quiz,
                             'result': True,
                             'note': note,
                             'nbquestion': i
                         })
Example #28
0
def show_page(request, path):
    slug = path.split('/')[-1] 
    #TODO: need to use full path to identify the page
    page = get_object_or_404(Page, "slug =",  slug)

    if request.method == "POST":
        if request.user.is_staff:
            setattr(page.storage,
                    request.POST['id'], db.Text(request.POST['value']))
            page.storage.put()
            return HttpResponse(request.POST['value'])
        else:
            raise Http404

    return render_to_response(request,
                              page.template.name,
                              {'page' : page })
Example #29
0
def event_show(request, key_id):
    key_id = int(key_id, 10)
    if request.user.is_authenticated():
        event = get_object_or_404(Event, id=key_id)
        fav = Favourite.all().filter('event =', event).filter('user ='******'invitation'):
        invitation = request.GET['invitation']
    else:
        invitation = 0
    extra_context = { 'is_fav' : fav,
                      'in_iframe' : True,
                      'invitation' : invitation,
                      'invitation_link' : get_facebook_app_url(request.path), }

    return object_detail(request, Event.all(), object_id=key_id, extra_context = extra_context)
Example #30
0
File: views.py Project: ryuic/newsy
def list(request, cat=None, blog=None, label=None):
    entry_obj = Entry.all().order('-created_at')

    if cat:
        cat_obj = CategoryCount.all().filter('category =', cat).get()
        if not cat_obj: raise Http404
        entry_obj.filter('cat_ref =', cat_obj)
        label = cat_obj.category
    elif blog:
        feed_obj = get_object_or_404(Feed, blog)
        entry_obj.filter('feed_ref =', feed_obj)
        label = feed_obj.name

    template_ext = 'xml' if request.GET.has_key('output') and request.GET.get('output') == 'rss' else 'html'

    return object_list(request, entry_obj, paginate_by=25,
                       extra_context={'label' : label, 'cat' : cat, 'blog' : blog},
                       template_name='archive/entry_list.%s' % template_ext)
Example #31
0
def users_photo(request, username, photo_key):
    viewed_user = User.get_user_by_username_or_404(username)
    photo = get_object_or_404(Photo, photo_key)
    
    if photo.user != viewed_user:
        raise Http404('Object does not exist!')
    
    extra_context = {
        'viewed_user': viewed_user,
        'photo': photo,
        'viewed_username': username
    }
    
    return object_list(request,
        queryset=Thumbnail.all().filter('photo_user', viewed_user).order('-photo_date_added'),
        template_name='photo/show.html',
        extra_context=extra_context
    )
Example #32
0
def stations_put(request, providerId):
  if request.method == "PUT":
    provider = get_object_or_404(Provider, id=int(providerId))
    
    data = request.raw_post_data
    try:
      xmltree = ET.XML(data)
    except:
      raise HttpResponseBadRequest()
    
    try:
      save_station_status(xmltree, provider)
      provider.locationsUpdated = datetime.datetime.now()
      provider.put()
      return HttpResponse("OK")
    except InvalidXML, e:
      return HttpResponseBadRequest(e.message)
    except InvalidXMLNode, e:
      return HttpResponseBadRequest(e.message)
Example #33
0
def detail(request, key_name):
    """
    Show details for a public suggestion, and a button to create a
    reminder from it.
    """
    suggestion = get_object_or_404(Reminder, key_name=key_name)
    logging.debug(request.method)
    email_form = EmailForm(request.POST)
    if request.method == "POST":
        user = request.user
        if user.is_anonymous() and email_form.is_valid():
            email = email_form.cleaned_data['email']
            existing = User.all().filter('email', email).fetch(1)
            if len(existing):
                return HttpResponseRedirect(
                    '/accounts/login/?email=%s&next=%s' %
                    (email, request.path))
            user = create_user(request, email)
        return create_reminder(request, user, suggestion)
    return render_to_response(
        request, 'suggestions/detail.html', locals())
Example #34
0
def flatpage(request, url):
    """
    Flat page view.

    Models: `flatpages.flatpages`
    Templates: Uses the template defined by the ``template_name`` field,
        or `flatpages/default.html` if template_name is not defined.
    Context:
        flatpage
            `flatpages.flatpages` object
    """
    if not url.endswith('/') and settings.APPEND_SLASH:
        return HttpResponseRedirect("%s/" % request.path)
    if not url.startswith('/'):
        url = "/" + url
    f = get_object_or_404(FlatPage, 'url =', url, 'sites = ', db.Key(settings.SITE_ID))
    # If registration is required for accessing this page, and the user isn't
    # logged in, redirect to the login page.
    if f.registration_required and not request.user.is_authenticated():
        from django.contrib.auth.views import redirect_to_login
        return redirect_to_login(request.path)
    if f.template_name:
        t = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
    else:
        t = loader.get_template(DEFAULT_TEMPLATE)

    # To avoid having to always use the "|safe" filter in flatpage templates,
    # mark the title and content as already safe (since they are raw HTML
    # content in the first place).
    f.title = mark_safe(f.title)
    f.content = mark_safe(f.content)

    c = RequestContext(request, {
        'flatpage': f,
    })
    response = HttpResponse(t.render(c))
    populate_xheaders(request, response, FlatPage, f.id)
    return response
Example #35
0
def facebook_show_animal_by_name(request,
                                 category=None,
                                 year=None,
                                 month=None,
                                 day=None,
                                 name=None):
    date_ = datetime.date(int(year), int(month), int(day))
    name = urllib.unquote_plus(name)
    animal = get_object_or_404(Animal, 'brought_to_shelter =', date_,
                               'category =', category, 'name = ',
                               name)  # todo: also check date
    return render_to_response(request,
                              "fb/animal_detail.html",
                              data={
                                  'object':
                                  animal,
                                  'page_title':
                                  _animal_page_title(animal),
                                  'template_wrapper':
                                  'base.html',
                                  'FB_APPLICATION_ID':
                                  settings.FACEBOOK_APPLICATION_ID
                              })
Example #36
0
File: views.py Project: ryuic/newsy
def entry_show(request, key):
    entry = get_object_or_404(Entry, key)

    #clustering
    wordcounts = []
    wordlist = []

    entries = Entry.all().filter('cat_ref =', entry.cat_ref).order('-created_at').fetch(20)

    for e in entries:
        wc = clusters.get_words(e)
        wordcounts.append(wc)
        for w in wc.keys():
            if w not in wordlist: wordlist.append(w)

    words = [[] for i in range(len(wordcounts))]

    for i, wc in enumerate(wordcounts):
        for word in wordlist:
            if word in wc: c = float(wc[word])
            else: c = 0.0
            words[i].append(c)

    kcluster = clusters.kcluster(words)
    #logging.debug(kcluster)

    similalities = []
    for cluster in kcluster:
        for i, c in enumerate(cluster):
            if entries[c] == entry:
                #similalities = cluster
                similalities = [entries[cl] for cl in cluster]
                break
    #logging.debug(similalities)

    return render_to_response(request, 'feed/entry_detail.html',
                              {'entry' : entry, 'similalities' : similalities})
Example #37
0
def download_albumentry(request,key):
    userfile = get_object_or_404(UserFile,key)
    filebin=userfile.filebin_set.get()
    if not userfile or not filebin:        
        return HttpResponseNotFound()
    response=HttpResponse(filebin.bin,content_type=guess_type(userfile.name)[0] or 'application/octet-stream')   

    #dealing with unicode :( Can't convert unicode to ascii when decode. 
    #If any solutions, please mail to me: [email protected] 
    if isinstance(userfile.name, unicode):
        response['Content-Type'] = 'application/octet-stream'
        encoding=sys.getdefaultencoding() 
        try :
            name=force_unicode(urllib.unquote(smart_str(userfile.name)))
            str=name.decode(encoding)
            filename=str.encode(encoding, 'replace')
            response['Content-Disposition'] = 'attachment; filename="%s"'%filename
        except UnicodeEncodeError:
            filename=userfile.name
            response['Content-Type']=userfile.mimetype 
    else:
        filename=userfile.name
        response['Content-Type']=userfile.mimetype 
    return response
Example #38
0
def detail(request, key_name):
    domain = get_object_or_404(Domain, key_name=key_name)
    return render_to_response(request, 'domains/detail.html', locals())
Example #39
0
def show_icon(request,key):
    userfile = get_object_or_404(UserFile,key)
    if userfile.icon:
        return HttpResponse(userfile.icon,'image/JPEG')
    return HttpResponseNotFound()