예제 #1
0
def locations_import_preview(request, id, template_name='locations/import-map-fields.html'):
    """
    This will generate a form based on the uploaded CSV for field mapping.
    A preview will be generated based on the mapping given.
    """
    locport = get_object_or_404(LocationImport, pk=id)
    
    if request.method == 'POST':
        form = ImportMapForm(request.POST, locport=locport)

        if form.is_valid():
            # Show the user a preview based on the mapping
            cleaned_data = form.cleaned_data
            file_path = os.path.join(settings.MEDIA_ROOT, locport.get_file().file.name)
            locations, stats = parse_locs_from_csv(file_path, cleaned_data)
            
            # return the form to use it for the confirm view
            template_name = 'locations/import-preview.html'
            return render_to_response(template_name, {
                'locations': locations,
                'stats': stats,
                'locport': locport,
                'form': form,
                'now': datetime.now(),
            }, context_instance=RequestContext(request))

    else:
        form = ImportMapForm(locport=locport)

    return render_to_response(template_name, {
        'form': form,
        'locport': locport,
        'now': datetime.now(),
        }, context_instance=RequestContext(request))
예제 #2
0
def delete(request, id, template_name="news/delete.html"):
    news = get_object_or_404(News, pk=id)

    # check permission
    if not has_perm(request.user, "news.delete_news"):
        raise Http403

    if request.method == "POST":
        log_defaults = {
            "event_id": 305300,
            "event_data": "%s (%d) deleted by %s" % (news._meta.object_name, news.pk, request.user),
            "description": "%s deleted" % news._meta.object_name,
            "user": request.user,
            "request": request,
            "instance": news,
        }
        EventLog.objects.log(**log_defaults)
        messages.add_message(request, messages.SUCCESS, "Successfully deleted %s" % news)

        # send notification to administrators
        recipients = get_notice_recipients("module", "news", "newsrecipients")
        if recipients:
            if notification:
                extra_context = {"object": news, "request": request}
                notification.send_emails(recipients, "news_deleted", extra_context)

        news.delete()
        return HttpResponseRedirect(reverse("news.search"))

    return render_to_response(template_name, {"news": news}, context_instance=RequestContext(request))
예제 #3
0
def approve(request, id, template_name="resumes/approve.html"):
    if not is_admin(request.user):
        raise Http403
    resume = get_object_or_404(Resume, pk=id)

    if request.method == "POST":
        resume.activation_dt = now_localized()
        resume.allow_anonymous_view = True
        resume.status = True
        resume.status_detail = 'active'

        if not resume.creator:
            resume.creator = request.user
            resume.creator_username = request.user.username

        if not resume.owner:
            resume.owner = request.user
            resume.owner_username = request.user.username

        resume.save()

        messages.add_message(request, messages.SUCCESS, 'Successfully approved %s' % resume)

        return HttpResponseRedirect(reverse('resume', args=[resume.slug]))

    return render_to_response(template_name, {'resume': resume},
            context_instance=RequestContext(request))
예제 #4
0
def edit_meta(request, id, form_class=MetaForm, template_name="resumes/edit-meta.html"):

    # check permission
    resume = get_object_or_404(Resume, pk=id)
    if not has_perm(request.user,'resumes.change_resume',resume):
        raise Http403

    defaults = {
        'title': resume.get_title(),
        'description': resume.get_description(),
        'keywords': resume.get_keywords(),
        'canonical_url': resume.get_canonical_url(),
    }
    resume.meta = MetaTags(**defaults)


    if request.method == "POST":
        form = form_class(request.POST, instance=resume.meta)
        if form.is_valid():
            resume.meta = form.save() # save meta
            resume.save() # save relationship

            messages.add_message(request, messages.SUCCESS, 'Successfully updated meta for %s' % resume)
            
            return HttpResponseRedirect(reverse('resume', args=[resume.slug]))
    else:
        form = form_class(instance=resume.meta)

    return render_to_response(template_name, {'resume': resume, 'form':form}, 
        context_instance=RequestContext(request))
예제 #5
0
def search(request, template_name="jobs/search.html"):
    query = request.GET.get('q', None)

    if get_setting('site', 'global', 'searchindex') and query:
        jobs = Job.objects.search(query, user=request.user)
    else:
        filters = get_query_filters(request.user, 'jobs.view_job')
        jobs = Job.objects.filter(filters).distinct()
        if not request.user.is_anonymous():
            jobs = jobs.select_related()

    jobs = jobs.order_by('status_detail','list_type','-post_dt')

    log_defaults = {
        'event_id': 254000,
        'event_data': '%s searched by %s' % ('Job', request.user),
        'description': '%s searched' % 'Job',
        'user': request.user,
        'request': request,
        'source': 'jobs'
    }
    EventLog.objects.log(**log_defaults)

    return render_to_response(template_name, {'jobs': jobs},
        context_instance=RequestContext(request))
예제 #6
0
def pricing_delete(request, id, template_name="jobs/pricing-delete.html"):
    job_pricing = get_object_or_404(JobPricing, pk=id)

    if not has_perm(request.user, 'jobs.delete_jobpricing'):
        raise Http403

    if request.method == "POST":
        log_defaults = {
            'event_id': 265120,
            'event_data': '%s (%d) deleted by %s' % (
                job_pricing._meta.object_name,
                job_pricing.pk,
                request.user
            ),
            'description': '%s deleted' % job_pricing._meta.object_name,
            'user': request.user,
            'request': request,
            'instance': job_pricing,
        }

        EventLog.objects.log(**log_defaults)
        messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % job_pricing)

        job_pricing.delete()

        return HttpResponseRedirect(reverse('job_pricing.search'))

    return render_to_response(template_name, {'job_pricing': job_pricing},
        context_instance=RequestContext(request))
예제 #7
0
def pricing_add(request, form_class=JobPricingForm, template_name="jobs/pricing-add.html"):
    if has_perm(request.user, 'jobs.add_jobpricing'):
        if request.method == "POST":
            form = form_class(request.POST)
            if form.is_valid():
                job_pricing = form.save(commit=False)
                job_pricing.status = 1
                job_pricing.save(request.user)

                log_defaults = {
                    'event_id': 265100,
                    'event_data': '%s (%d) added by %s' % (
                        job_pricing._meta.object_name,
                        job_pricing.pk,
                        request.user
                    ),
                    'description': '%s added' % job_pricing._meta.object_name,
                    'user': request.user,
                    'request': request,
                    'instance': job_pricing,
                }
                EventLog.objects.log(**log_defaults)

                return HttpResponseRedirect(reverse('job_pricing.view', args=[job_pricing.id]))
        else:
            form = form_class()

        return render_to_response(template_name, {'form': form},
            context_instance=RequestContext(request))
    else:
        raise Http403
예제 #8
0
def edit(request, id, form_class=FileForm, template_name="files/edit.html"):
    file = get_object_or_404(File, pk=id)

    # check permission
    if not has_perm(request.user,'files.change_file',file):  
        raise Http403

    if request.method == "POST":

        form = form_class(request.POST, request.FILES, instance=file, user=request.user)

        if form.is_valid():
            file = form.save(commit=False)
            file.name = file.file.path.split('/')[-1]

            # update all permissions and save the model
            file = update_perms_and_save(request, form, file)

            log_defaults = {
                'event_id' : 182000,
                'event_data': '%s (%d) edited by %s' % (file._meta.object_name, file.pk, request.user),
                'description': '%s edited' % file._meta.object_name,
                'user': request.user,
                'request': request,
                'instance': file,
            }
            EventLog.objects.log(**log_defaults)

            return HttpResponseRedirect(reverse('file.search'))
    else:
        form = form_class(instance=file, user=request.user)

    return render_to_response(template_name, {'file': file, 'form':form}, 
        context_instance=RequestContext(request))
예제 #9
0
def photoset_view_latest(request, template_name="photos/photo-set/latest.html"):
    """ View latest photo set """

    query = request.GET.get('q', None)
    if get_setting('site', 'global', 'searchindex') and query:
        photo_sets = PhotoSet.objects.search(query, user=request.user)
    else:
        filters = get_query_filters(request.user, 'photos.view_photoset')
        photo_sets = PhotoSet.objects.filter(filters).distinct()
        if not request.user.is_anonymous():
            photo_sets = photo_sets.select_related()
    photo_sets = photo_sets.order_by('-create_dt')

    log_defaults = {
        'event_id' : 991400,
        'event_data': '%s searched by %s' % ('PhotoSet', request.user),
        'description': '%s searched' % 'PhotoSet',
        'user': request.user,
        'request': request,
        'source': 'photos'
    }
    EventLog.objects.log(**log_defaults)

    return render_to_response(template_name, {"photo_sets": photo_sets}, 
        context_instance=RequestContext(request))
예제 #10
0
def photoset_delete(request, id, template_name="photos/photo-set/delete.html"):
    photo_set = get_object_or_404(PhotoSet, id=id)

    # if no permission; permission exception
    if not has_perm(request.user,'photos.delete_photoset',photo_set):
        raise Http403
    
    if request.method == "POST":
        EventLog.objects.log(**{
            'event_id' : 991300,
            'event_data': '%s (%d) deleted by %s' % (photo_set._meta.object_name, photo_set.pk, request.user),
            'description': '%s deleted' % photo_set._meta.object_name,
            'user': request.user,
            'request': request,
            'instance': photo_set,
        })
        photo_set.delete()

        # soft delete all images in photo set
        Image.objects.filter(photoset=photo_set).delete()

        messages.add_message(request, messages.INFO, 'Photo Set %s deleted' % photo_set)
        
        if "delete" in request.META.get('HTTP_REFERER', None):
            #if the referer is the get page redirect to the photo set search
            return redirect('photoset_latest')

        return HttpResponseRedirect(request.META.get('HTTP_REFERER', None))
    
    return render_to_response(template_name, {
        'photo_set': photo_set,
    }, context_instance=RequestContext(request))
예제 #11
0
def delete(request, id, set_id=0):
    """ delete photo """
    photo = get_object_or_404(Image, id=id)

    # permissions
    if not has_perm(request.user,'photologue.delete_photo',photo):
        raise Http403

    if request.method == "POST":
        request.user.message_set.create(message=_("Successfully deleted photo '%s'") % photo.title)
        log_defaults = {
            'event_id' : 990300,
            'event_data': '%s (%d) deleted by %s' % (photo._meta.object_name, photo.pk, request.user),
            'description': '%s deleted' % photo._meta.object_name,
            'user': request.user,
            'request': request,
            'instance': photo,
        }
        EventLog.objects.log(**log_defaults)

        photo.delete()

        messages.add_message(request, messages.INFO, 'Photo %s deleted' % id)
        
        try:
            photo_set = PhotoSet.objects.get(id=set_id)
            return HttpResponseRedirect(reverse("photoset_details", args=[set_id]))
        except PhotoSet.DoesNotExist:
            return HttpResponseRedirect(reverse("photos_search"))

    return render_to_response("photos/delete.html", {
        "photo": photo,
    }, context_instance=RequestContext(request))
예제 #12
0
def memberphotos(request, username, template_name="photos/memberphotos.html", group_slug=None, bridge=None):
    """ Get the members photos and display them """
    
    if bridge:
        try:
            group = bridge.get_group(group_slug)
        except ObjectDoesNotExist:
            raise Http404
    else:
        group = None
    
    user = get_object_or_404(User, username=username)
    
    photos = Image.objects.filter(
        member__username = username,
        is_public = True
    )
    
    if group:
        photos = group.content_objects(photos, join="pool")
    else:
        photos = photos.filter(pool__object_id=None)
    
    photos = photos.order_by("-date_added")
    
    return render_to_response(template_name, {
        "group": group,
        "photos": photos,
    }, context_instance=RequestContext(request))
예제 #13
0
def photo(request, id, set_id=0, partial=False, template_name="photos/details.html"):
    """ photo details """

    photo = get_object_or_404(Image, id=id)
    if not has_perm(request.user, 'photologue.view_photo', photo):
        raise Http403

    EventLog.objects.log(**{
        'event_id' : 990500,
        'event_data': '%s (%d) viewed by %s' % (photo._meta.object_name, photo.pk, request.user),
        'description': '%s viewed' % photo._meta.object_name,
        'user': request.user,
        'request': request,
        'instance': photo,
    })

    # default prev/next URL
    photo_prev_url, photo_next_url = '', ''

    if set_id:
        photo_set = get_object_or_404(PhotoSet, id=set_id)
        photo_prev = photo.get_prev(set=set_id)
        photo_next = photo.get_next(set=set_id)            

        if photo_prev: photo_prev_url = reverse("photo", args= [photo_prev.id, set_id])
        if photo_next: photo_next_url = reverse("photo", args= [photo_next.id, set_id])

        photo_sets = list(photo.photoset.all())
        if photo_set in photo_sets:
            photo_sets.remove(photo_set)
            photo_sets.insert(0, photo_set)
        else:
            set_id = 0
    else:
        photo_prev = photo.get_prev()
        photo_next = photo.get_next()

        if photo_prev: photo_prev_url = reverse("photo", args= [photo_prev.id])
        if photo_next: photo_next_url = reverse("photo", args= [photo_next.id])  

        photo_sets = photo.photoset.all()
        if photo_sets:
            set_id = photo_sets[0].id

    # "is me" variable
    is_me = photo.member == request.user

    if partial:  # return partial html; for ajax end-user
        template_name = "photos/partial-details.html"

    return render_to_response(template_name, {
        "photo_prev_url": photo_prev_url,
        "photo_next_url": photo_next_url,
        "photo": photo,
        "photo_sets": photo_sets,
        "photo_set_id": set_id,
        "id": id,
        "set_id": set_id,
        "is_me": is_me,
    }, context_instance=RequestContext(request))
예제 #14
0
def edit(request, id, form_class=NewsForm, template_name="news/edit.html"):
    news = get_object_or_404(News, pk=id)

    # check permission
    if not has_perm(request.user, "news.change_news", news):
        raise Http403

    form = form_class(instance=news, user=request.user)

    if request.method == "POST":
        form = form_class(request.POST, instance=news, user=request.user)
        if form.is_valid():
            news = form.save(commit=False)

            # update all permissions and save the model
            news = update_perms_and_save(request, form, news)

            log_defaults = {
                "event_id": 305200,
                "event_data": "%s (%d) edited by %s" % (news._meta.object_name, news.pk, request.user),
                "description": "%s edited" % news._meta.object_name,
                "user": request.user,
                "request": request,
                "instance": news,
            }
            EventLog.objects.log(**log_defaults)

            messages.add_message(request, messages.SUCCESS, "Successfully updated %s" % news)

            return HttpResponseRedirect(reverse("news.view", args=[news.slug]))

    return render_to_response(template_name, {"news": news, "form": form}, context_instance=RequestContext(request))
예제 #15
0
def index(request, slug=None, template_name="news/view.html"):
    if not slug:
        return HttpResponseRedirect(reverse("news.search"))
    news = get_object_or_404(News, slug=slug)

    # non-admin can not view the non-active content
    # status=0 has been taken care of in the has_perm function
    if (news.status_detail).lower() <> "active" and (not is_admin(request.user)):
        raise Http403

    # check permission
    if not has_perm(request.user, "news.view_news", news):
        raise Http403

    log_defaults = {
        "event_id": 305500,
        "event_data": "%s (%d) viewed by %s" % (news._meta.object_name, news.pk, request.user),
        "description": "%s viewed" % news._meta.object_name,
        "user": request.user,
        "request": request,
        "instance": news,
    }
    EventLog.objects.log(**log_defaults)

    return render_to_response(template_name, {"news": news}, context_instance=RequestContext(request))
예제 #16
0
def nearest(request, template_name="locations/nearest.html"):
    locations = []
    lat, lng = None, None
    query = request.GET.get('q')
    filters = get_query_filters(request.user, 'locations.view_location')

    if query:
        lat, lng = get_coordinates(address=query)

    all_locations = Location.objects.filter(filters).distinct()
    if not request.user.is_anonymous():
        all_locations = all_locations.select_related()

    if all((lat,lng)):
        for location in all_locations:
            location.distance = location.get_distance2(lat, lng)
            if location.distance != None:
                locations.append(location)
            locations.sort(key=lambda x: x.distance)

    log_defaults = {
        'event_id' : 834100,
        'event_data': '%s nearest to %s' % ('Location', request.user),
        'description': '%s nearest' % 'Location',
        'user': request.user,
        'request': request,
        'source': 'locations'
    }
    EventLog.objects.log(**log_defaults)

    return render_to_response(template_name, {
        'locations':locations,
        'origin': {'lat':lat,'lng':lng},
        }, context_instance=RequestContext(request))
예제 #17
0
def add(request, form_class=NavForm, template_name="navs/add.html"):
    if not has_perm(request.user, 'navs.add_nav'):
        raise Http403
    
    if request.method == "POST":
        form = form_class(request.POST, user=request.user)
        if form.is_valid():
            nav = form.save(commit=False)
            nav = update_perms_and_save(request, form, nav)
            log_defaults = {
                    'event_id' : 195100,
                    'event_data': '%s (%d) added by %s' % (nav._meta.object_name, nav.pk, request.user),
                    'description': '%s added' % nav._meta.object_name,
                    'user': request.user,
                    'request': request,
                    'instance': nav,
                }
            EventLog.objects.log(**log_defaults)
            messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % nav)
            return redirect('navs.edit_items', id=nav.id)
    else:
        form = form_class(user=request.user)
        
    return render_to_response(
        template_name,
        {'form':form},
        context_instance=RequestContext(request),
    )
예제 #18
0
def photoset_details(request, id, template_name="photos/photo-set/details.html"):
    """ View photos in photo set """
    
    photo_set = get_object_or_404(PhotoSet, id=id)
    if not has_view_perm(request.user, 'photos.view_photoset', photo_set):
        raise Http403
    
    order = get_setting('module', 'photos', 'photoordering')
    if order == 'descending':
        photos = photo_set.get_images(user=request.user).order_by('-pk')
    else:
        photos = photo_set.get_images(user=request.user).order_by('pk')
    
    EventLog.objects.log(**{
        'event_id' : 991500,
        'event_data': '%s (%d) viewed by %s' % (photo_set._meta.object_name, photo_set.pk, request.user),
        'description': '%s viewed' % photo_set._meta.object_name,
        'user': request.user,
        'request': request,
        'instance': photo_set,
    })

    return render_to_response(template_name, {
        "photos": photos,
        "photo_set": photo_set,
    }, context_instance=RequestContext(request))
예제 #19
0
def delete(request, id, template_name="files/delete.html"):
    file = get_object_or_404(File, pk=id)

    # check permission
    if not has_perm(request.user,'files.delete_file'): 
        raise Http403

    if request.method == "POST":
        log_defaults = {
            'event_id' : 183000,
            'event_data': '%s (%d) deleted by %s' % (file._meta.object_name, file.pk, request.user),
            'description': '%s deleted' % file._meta.object_name,
            'user': request.user,
            'request': request,
            'instance': file,
        }
        EventLog.objects.log(**log_defaults)

        file.delete()

        if 'ajax' in request.POST:
            return HttpResponse('Ok')
        else:
            return HttpResponseRedirect(reverse('file.search'))
        

    return render_to_response(template_name, {'file': file}, 
        context_instance=RequestContext(request))
예제 #20
0
def photoset_zip(request, id, template_name="photos/photo-set/zip.html"):
    """ Generate zip file for the entire photo set
    for admins only.
    """
    
    photo_set = get_object_or_404(PhotoSet, id=id)
    
    #admin only
    if not is_admin(request.user):
        raise Http403
    
    file_path = ""
    task_id = ""
    if not settings.CELERY_IS_ACTIVE:
        task = ZipPhotoSetTask()
        file_path = task.run(photo_set)        
    else:
        task = ZipPhotoSetTask.delay(photo_set)
        task_id = task.task_id
    
    return render_to_response(template_name, {
        "photo_set": photo_set,
        "task_id":task_id,
        "file_path":file_path,
    }, context_instance=RequestContext(request))
예제 #21
0
def pricing_edit(request, id, form_class=JobPricingForm, template_name="jobs/pricing-edit.html"):
    job_pricing = get_object_or_404(JobPricing, pk=id)
    if not has_perm(request.user, 'jobs.change_jobpricing', job_pricing):
        Http403

    if request.method == "POST":
        form = form_class(request.POST, instance=job_pricing)
        if form.is_valid():
            job_pricing = form.save(commit=False)
            job_pricing.save(request.user)

            log_defaults = {
                'event_id': 265110,
                'event_data': '%s (%d) edited by %s' % (
                    job_pricing._meta.object_name,
                    job_pricing.pk,
                    request.user
                ),
                'description': '%s edited' % job_pricing._meta.object_name,
                'user': request.user,
                'request': request,
                'instance': job_pricing,
            }
            EventLog.objects.log(**log_defaults)

            return HttpResponseRedirect(reverse(
                'job_pricing.view',
                args=[job_pricing.id])
            )
    else:
        form = form_class(instance=job_pricing)

    return render_to_response(template_name, {'form': form},
        context_instance=RequestContext(request))
예제 #22
0
def add(request, form_class=LocationForm, template_name="locations/add.html"):
    if has_perm(request.user,'locations.add_location'):
        if request.method == "POST":
            form = form_class(request.POST, user=request.user)
            if form.is_valid():           
                location = form.save(commit=False)

                # update all permissions and save the model
                location = update_perms_and_save(request, form, location)
 
                log_defaults = {
                    'event_id' : 831000,
                    'event_data': '%s (%d) added by %s' % (location._meta.object_name, location.pk, request.user),
                    'description': '%s added' % location._meta.object_name,
                    'user': request.user,
                    'request': request,
                    'instance': location,
                }
                EventLog.objects.log(**log_defaults)
                
                messages.add_message(request, messages.SUCCESS, 'Successfully added %s' % location)
                
                return HttpResponseRedirect(reverse('location', args=[location.pk]))
        else:
            form = form_class(user=request.user)
           
        return render_to_response(template_name, {'form':form}, 
            context_instance=RequestContext(request))
    else:
        raise Http403
예제 #23
0
def approve(request, id, template_name="jobs/approve.html"):
    can_view_jobs = has_perm(request.user, 'jobs.view_job')
    can_change_jobs = has_perm(request.user, 'jobs.change_job')
    
    if not all([can_view_jobs, can_change_jobs]):
        raise Http403
    
    job = get_object_or_404(Job, pk=id)

    if request.method == "POST":
        job.activation_dt = now_localized()
        job.allow_anonymous_view = True
        job.status = True
        job.status_detail = 'active'

        if not job.creator:
            job.creator = request.user
            job.creator_username = request.user.username

        if not job.owner:
            job.owner = request.user
            job.owner_username = request.user.username

        job.save()

        messages.add_message(request, messages.SUCCESS, 'Successfully approved %s' % job)

        return HttpResponseRedirect(reverse('job', args=[job.slug]))

    return render_to_response(template_name, {'job': job},
            context_instance=RequestContext(request))
예제 #24
0
def locations_import_upload(request, template_name='locations/import-upload-file.html'):
    """
    This is the upload view for the location imports.
    This will upload the location import file and then redirect the user
    to the import mapping/preview page of the import file
    """
    if request.method == 'POST':
        form = UploadForm(request.POST, request.FILES)
        if form.is_valid():
            cleaned_data = form.cleaned_data
            
            locport = LocationImport.objects.create(creator=request.user)
            csv = File.objects.save_files_for_instance(request, locport)[0]
            file_path = os.path.join(settings.MEDIA_ROOT, csv.file.name)
            import_valid, import_errs = is_import_valid(file_path)

            if not import_valid:
                for err in import_errs:
                    messages.add_message(request, messages.ERROR, err)
                locport.delete()
                return redirect('locations_import_upload_file')

            return redirect('locations_import_preview', locport.id)
    else:
        form = UploadForm()

    return render_to_response(template_name, {
            'form': form,
            'now': datetime.now(),
        }, context_instance=RequestContext(request))
예제 #25
0
def edit(request, id, form_class=ResumeForm, template_name="resumes/edit.html"):
    resume = get_object_or_404(Resume, pk=id)

    if has_perm(request.user,'resumes.change_resume',resume):    
        if request.method == "POST":
            form = form_class(request.POST, instance=resume, user=request.user)
            if form.is_valid():
                resume = form.save(commit=False)
                resume = update_perms_and_save(request, form, resume)

                log_defaults = {
                    'event_id' : 352000,
                    'event_data': '%s (%d) edited by %s' % (resume._meta.object_name, resume.pk, request.user),
                    'description': '%s edited' % resume._meta.object_name,
                    'user': request.user,
                    'request': request,
                    'instance': resume,
                }
                EventLog.objects.log(**log_defaults) 
                
                messages.add_message(request, messages.SUCCESS, 'Successfully updated %s' % resume)
                                                              
                return HttpResponseRedirect(reverse('resume', args=[resume.slug]))             
        else:
            form = form_class(instance=resume, user=request.user)

        return render_to_response(template_name, {'resume': resume, 'form':form}, 
            context_instance=RequestContext(request))
    else:
        raise Http403
예제 #26
0
def locations_import_confirm(request, id, template_name='locations/import-confirm.html'):
    """
    Confirm the locations import and continue with the process.
    This can only be accessed via a hidden post form from the preview page.
    That will hold the original mappings selected by the user.
    """
    locport = get_object_or_404(LocationImport, pk=id)
    
    if request.method == "POST":
        form = ImportMapForm(request.POST, locport=locport)

        if form.is_valid():
            cleaned_data = form.cleaned_data
            file_path = os.path.join(settings.MEDIA_ROOT, locport.get_file().file.name)

            if not settings.CELERY_IS_ACTIVE:
                # if celery server is not present 
                # evaluate the result and render the results page
                result = ImportLocationsTask()
                locations, stats = result.run(request.user, file_path, cleaned_data)
                return render_to_response(template_name, {
                    'locations': locations,
                    'stats': stats,
                    'now': datetime.now(),
                }, context_instance=RequestContext(request))
            else:
                result = ImportLocationsTask.delay(request.user, file_path, cleaned_data)

            return redirect('locations_import_status', result.task_id)
    else:
        return redirect('locations_import_preview', locport.id)
예제 #27
0
def delete(request, id, template_name="resumes/delete.html"):
    resume = get_object_or_404(Resume, pk=id)

    if has_perm(request.user,'resumes.delete_resume'):   
        if request.method == "POST":
            log_defaults = {
                'event_id' : 433000,
                'event_data': '%s (%d) deleted by %s' % (resume._meta.object_name, resume.pk, request.user),
                'description': '%s deleted' % resume._meta.object_name,
                'user': request.user,
                'request': request,
                'instance': resume,
            }
            
            EventLog.objects.log(**log_defaults)
            messages.add_message(request, messages.SUCCESS, 'Successfully deleted %s' % resume)
            
            # send notification to administrators
            recipients = get_notice_recipients('module', 'resumes', 'resumerecipients')
            if recipients:
                if notification:
                    extra_context = {
                        'object': resume,
                        'request': request,
                    }
                    notification.send_emails(recipients,'resume_deleted', extra_context)
            
            resume.delete()
                
            return HttpResponseRedirect(reverse('resume.search'))
    
        return render_to_response(template_name, {'resume': resume}, 
            context_instance=RequestContext(request))
    else:
        raise Http403
예제 #28
0
def search(request, template_name="locations/search.html"):
    query = request.GET.get('q', None)

    if get_setting('site', 'global', 'searchindex') and query:
        locations = Location.objects.search(query, user=request.user)
    else:
        filters = get_query_filters(request.user, 'locations.view_location')
        locations = Location.objects.filter(filters).distinct()
        if not request.user.is_anonymous():
            locations = locations.select_related()

    locations = locations.order_by('-create_dt')

    log_defaults = {
        'event_id' : 834000,
        'event_data': '%s listed by %s' % ('Location', request.user),
        'description': '%s listed' % 'Location',
        'user': request.user,
        'request': request,
        'source': 'locations'
    }
    EventLog.objects.log(**log_defaults)
    
    return render_to_response(template_name, {'locations':locations}, 
        context_instance=RequestContext(request))
예제 #29
0
def search(request, template_name="resumes/search.html"):
    """
    This page lists out all resumes from newest to oldest.
    If a search index is available, this page will also
    have the option to search through resumes.
    """
    has_index = get_setting('site', 'global', 'searchindex')
    query = request.GET.get('q', None)

    if has_index and query:
        resumes = Resume.objects.search(query, user=request.user)
    else:
        filters = get_query_filters(request.user, 'resumes.view_resume')
        resumes = Resume.objects.filter(filters).distinct()
        if request.user.is_authenticated():
            resumes = resumes.select_related()
    resumes = resumes.order_by('-create_dt')

    EventLog.objects.log(**{
        'event_id' : 354000,
        'event_data': '%s searched by %s' % ('Resume', request.user),
        'description': '%s searched' % 'Resume',
        'user': request.user,
        'request': request,
        'source': 'resumes'
    })
    
    return render_to_response(template_name, {'resumes':resumes}, 
        context_instance=RequestContext(request))
예제 #30
0
def edit_meta(request, id, form_class=MetaForm, template_name="news/edit-meta.html"):

    # check permission
    news = get_object_or_404(News, pk=id)
    if not has_perm(request.user, "news.change_news", news):
        raise Http403

    defaults = {
        "title": news.get_title(),
        "description": news.get_description(),
        "keywords": news.get_keywords(),
        "canonical_url": news.get_canonical_url(),
    }
    news.meta = MetaTags(**defaults)

    if request.method == "POST":
        form = form_class(request.POST, instance=news.meta)
        if form.is_valid():
            news.meta = form.save()  # save meta
            news.save()  # save relationship

            messages.add_message(request, messages.SUCCESS, "Successfully updated meta for %s" % news)

            return HttpResponseRedirect(reverse("news.view", args=[news.slug]))
    else:
        form = form_class(instance=news.meta)

    return render_to_response(template_name, {"news": news, "form": form}, context_instance=RequestContext(request))