Example #1
0
def pvt_message(request, receiver):
    """This function will store pvt msgs in db
        and send a notification mail to receiver"""    
    if request.method == "POST":
        referer = request.META.get('HTTP_REFERER', '')
        sender = request.user
        receiver_username =  request.POST.get('receiver_username', False) 
        receiver = get_object_or_404(User, username=receiver_username)
        msg = request.POST.get('pvt_msg', False) 
        account = get_object_or_404(Account, user=sender, provider=0)
        if isfollowing(receiver, sender) or is_in_group(sender,'team'):
            if sender.is_active == 4:
                request.session['flash'] = "You are temporarily not allowed to message someone. Please contact [email protected]"
                return redirect_to(request, referer)
            message = Private_Message(sender=sender, receiver=receiver,
                                  message=msg, account=account)
            message.save()
            list_filter = List_Filter(receiver_user = receiver, pm = message,status=0)
            list_filter.save()
            sent_filter = Sent_Filter(sender_user = sender, pm = message)
            sent_filter.save()
            request.session['flash'] = "Your private message was sent"
            params_for_mail = {'#_1':receiver.username,'#_2':sender.username, '#_3':msg, '#_4':str(message.id)}
            send_mail(str(receiver.email), 'kwippy <*****@*****.**>', 'private_message', params_for_mail)
            send_im(receiver,'private_message', params_for_mail)
            return redirect_to(request, referer)
        else:
            request.session['flash'] = "You cannot send this message"
            return redirect_to(request, referer)
Example #2
0
def poll_vote(request, id, choice, **kwargs):
    """Votes the selected choice.
    """
    from datetime import datetime

    poll = get_object_or_404(Poll, id=id)

    if poll.due_date is not None and poll.due_date < datetime.now():
        messages.warning(request, _("Sorry, this poll is already closed."))
        return redirect_to(request, permanent=False, url=poll.get_absolute_url())

    try:
        owner = request.user
        choices = poll.choices.all()
        choice_obj = choices[int(choice)]
        previous_vote = Vote.objects.get_for_models(choices).filter(owner=owner)
        if previous_vote.count() == 0:
            messages.success(request, _("Thank you for your vote."))
        else:
            previous_vote.delete()
            messages.success(request, _("Thank you. Your vote was updated successfully."))
        new_vote = Vote.objects.create(owner=owner, content_object=choice_obj)

    except IndexError:
        messages.error(request, _("Sorry, you selected an invalid choice."))

    return redirect_to(request, permanent=False, url=poll.get_absolute_url())
Example #3
0
def double_digit_checker(request,year,month,day=None):
    if len(month) == 1:
        try:
            url = reverse(
                "blog:archive_month",
                args=[year,"0%s" % month]
            )
        except:
            raise Http404
        return redirect_to(
            request,
            url
        )
    if day and len(day) == 1:
        try:
            url = reverse(
                "blog:archive_month",
                args=[year,month,"0%s" % day]
            )
        except:
            raise Http404
        return redirect_to(
            request,
            url
        )
    return None
Example #4
0
def world_detail_master_users(request, world_id):
    '''Process the user changes and redirect to world master.'''
    world = get_object_or_404(World, pk=world_id)
    
    user_membership = world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    if not user_membership.is_master:
        request.user.message_set.create(message = 'You are not authorized to edit this world.')
        return HttpResponseRedirect(world.get_absolute_url())
        
    if request.method == 'POST':
        formset = MembershipFormSet(request.POST, 
                queryset = Membership.objects.filter(world = world).order_by('user__user__username'))
        if formset.is_valid():
            instances = formset.save()
            for membership in instances:
                if membership.approved == True and membership.user.user.is_active == False:
                    user = membership.user.user
                    user.is_active = True
                    user.save()
            
            request.user.message_set.create(message = "Users edited successfully.")
            return HttpResponseRedirect(world.get_absolute_url() + 'master/')
    else:
        return redirect_to(request, url=world.get_absolute_url + 'master/')
Example #5
0
def complete_profile(request):

    p = request.user.get_profile()
    if p.is_profile_complete(): return redirect_to(request, reverse('dashboard'))

    form = CompleteProfileForm(instance = p)
    if request.method == 'POST':
    
        form = CompleteProfileForm(request.POST, instance=p)
        if form.is_valid():
            
            request.user.userdata_set.create(
                                             weight=form.cleaned_data['current_weight'], 
                                             waist=form.cleaned_data['current_waist'])
            form.save()
            request.user.save()
            
            request.user.message_set.create(message="Uzupełniono profil")
            
            try:
                FlatPage.objects.get(url='/wprowadzenie/')
                return redirect_to(request, '/wprowadzenie/')
            except FlatPage.DoesNotExist: #@UndefinedVariable
                return redirect_to(reverse('dashboard'), '/wprowadzenie/')
            

    
    return direct_to_template(request, "home/complete_profile.html", extra_context= {'form':form })
Example #6
0
def poll_vote(request, id, choice, **kwargs):
    """Votes the selected choice.
    """
    from datetime import datetime

    poll = get_object_or_404(Poll, id=id)

    if poll.due_date is not None and poll.due_date < datetime.now():
        messages.warning(request, _("Sorry, this poll is already closed."))
        return redirect_to(request,
                           permanent=False,
                           url=poll.get_absolute_url())

    try:
        owner = request.user
        choices = poll.choices.all()
        choice_obj = choices[int(choice)]
        previous_vote = Vote.objects.get_for_models(choices).filter(
            owner=owner)
        if previous_vote.count() == 0:
            messages.success(request, _("Thank you for your vote."))
        else:
            previous_vote.delete()
            messages.success(
                request, _("Thank you. Your vote was updated successfully."))
        new_vote = Vote.objects.create(owner=owner, content_object=choice_obj)

    except IndexError:
        messages.error(request, _("Sorry, you selected an invalid choice."))

    return redirect_to(request, permanent=False, url=poll.get_absolute_url())
Example #7
0
def feedback(request):

    page_title = u"Feedback"
    breadcrumbs = [{"url": reverse("feedback"), "title": page_title}]

    user = None
    if request.user.is_authenticated():
        user = request.user

    form = FeedbackForm(user=user)

    if request.method == "POST":
        if "send" in request.POST:
            form = FeedbackForm(request.POST, user=user)
            if form.is_valid():
                message = form.save(commit=False)
                if user is not None:
                    message.name = ("%s %s" % (user.first_name, user.last_name)).strip()
                    message.email = user.email
                message.save()
                messages.success(request, u"Thank you, your feedback message was sent to site administrators.")
                return redirect_to(request, reverse("frontpage"), permanent=False)
            else:
                messages.error(request, u"Please correct the indicated errors.")
        elif "cancel" in request.POST:
            return redirect_to(request, reverse("frontpage"), permanent=False)

    disable_getsatisfaction_tab = True
    return direct_to_template(request, "feedback/feedback.html", locals())
Example #8
0
def dissociate(
    request,
    template_name="authopenid/dissociate.html",
    dissociate_form=OpenidDissociateForm,
    redirect_field_name=REDIRECT_FIELD_NAME,
    default_redirect=settings.LOGIN_REDIRECT_URL,
    extra_context=None,
):
    """ view used to dissociate an openid from an account """
    nb_associated_openids, associated_openids = get_associate_openid(request.user)
    if nb_associated_openids == 1 and not request.user.has_usable_password() and request.method != "GET":
        msg = ["You can't remove this openid, you should set a password first."]
        return render_to_response(
            "authopenid/associate.html",
            {"associated_openids": associated_openids, "nb_associated_openids": nb_associated_openids, "msg": msg},
            context_instance=RequestContext(request),
        )

    if request.POST:
        if request.POST.get("bdissociate_cancel", "") == "Cancel":
            msg = ["Operation Cancel."]
            return redirect_to(request, "/accounts/openid/associate/")

        openid_urls = request.POST.getlist("a_openids_remove")
        if len(openid_urls) >= 1:
            for openid_url in openid_urls:
                UserAssociation.objects.get(openid_url__exact=openid_url).delete()
                if openid_url == request.session.get("openid_url"):
                    del request.session["openid_url"]
                msg = "Openid removed."

            request.user.message_set.create(message=msg)
            return redirect_to(request, "/accounts/openid/associate")
    else:
        return redirect_to(request, "/accounts/openid/associate")
Example #9
0
def cluster_accounts_new(request, cluster_id):
    """"""
    try:
        cluster = Cluster.objects.get(id = cluster_id)
    except Exception:
        return HttpResponse('this cluster doesn\'t exist')

    if request.method == 'POST':

        ClusterAccountFilledFormSet = modelformset_factory(ClusterAccount,
            form = ClusterAccountForm,
            can_delete = True,
            extra = 0)

        ClusterAccountFormSet = modelformset_factory(ClusterAccount,
            form = ClusterAccountForm,
            extra = 3)

        formset = ClusterAccountFormSet(request.POST)
        formset_filled = ClusterAccountFilledFormSet(request.POST, prefix = 'filled')

        if formset_filled.is_valid():
            formset_filled.save()

        if formset.is_valid():
            for form in formset.save(commit = False):
                form.cluster = cluster
                form.save()

        if 'more' in request.POST:
            return redirect_to(request, '/cluster/%s/provision/accounts/' % cluster_id)
        else:
            return redirect_to(request, '/cluster/%s/provision/' % cluster_id)
Example #10
0
def change_plan(request):
    if request.method == 'POST':
        user_plan = get_user_plan(request)
        new_plan = request.POST.get('plan')
        new_price_plan = PricePlan.objects.filter(active=True, slug=new_plan)
        if new_plan != user_plan.price_plan.slug and new_price_plan:
            recurly = Recurly(**settings.RECURLY)
            
            update_data = {
              'timeframe': 'renewal',
              'plan_code': new_plan,
            }
            update_result = recurly.accounts.subscription.update(account_code=user_plan.recurly_account_code, data=update_data)
            logging.debug(update_result)
            
            new_user_plan = UserPlan(price_plan=new_price_plan[0], account=user_plan.account, 
                                 recurly_account_code=update_result['account_code'],
                                 recurly_login_token=user_plan.recurly_login_token,
                                 card_set_up=user_plan.card_set_up)
            user_plan.end_date = datetime.datetime.now()
            user_plan.save()
            new_user_plan.save()
            
            set_message(request, 'plan_changed', context={'old_user_plan': user_plan, 'new_user_plan': new_user_plan})
            return redirect_to(request, reverse('administer_site',args=[request.user.get_profile().last_website_id]))
        else:
            set_message(request, 'plan_not_changed', level='attention', context={'user_plan': user_plan})
            return redirect_to(request, reverse('choose_plan'))  
    else:
        return HttpResponseBadRequest()
Example #11
0
def rename_tag(request):
    from django.utils.http import urlquote
    
    key = request.POST['key']
    value = request.POST.get('value', None)
    
    if value:
        tags = Tag.objects.filter(key=key, value=value)
    else:
        tags = Tag.objects.filter(key=key)

    for tag in tags:
        if value and 'new_value' in request.POST:
            tag.value = request.POST['new_value']
        if 'new_key' in request.POST:
            tag.key = request.POST['new_key']
        tag.save()
    
    if 'new_key' in request.POST:
        if 'new_value' in request.POST:    
            return redirect_to(request, reverse('openresources_tag', kwargs={'key':urlquote(request.POST['new_key']), 'value': urlquote(request.POST['new_value'])}))
        return redirect_to(request, reverse('openresources_tag_key', kwargs={'key':urlquote(request.POST['new_key'])}))

    if value:
        return redirect_to(request, reverse('openresources_tag', kwargs={'key':urlquote(key), 'value': urlquote(value)}))
    
    return redirect_to(request, reverse('openresources_tag_key', kwargs={'key':urlquote(key)}))
Example #12
0
def submit(request, recipients=None, debug=False, redirect_url=None):
    """
    Submit the contact form request.
    
    recipients: 
        the recipients to which the rendered form will be sent
    debug:
        if True, do everything but actually send the message
    redirect_url:
        if supplied, redirect a non-POST request to this url rather than raise a 404 error
    """
    if request.method == "POST":
        args = { 'success' : False }
        form = ContactForm(request.POST)
        if form.is_valid():
            sender = render_sender(form.cleaned_data)
            subject = render_subject(form.cleaned_data) 
            message = render_message(form.cleaned_data)
            
            if not debug:
                send_mail(subject, message, sender, recipients, fail_silently=False) #,auth_user=None, auth_password=None, connection=None)
            
            args = form.cleaned_data
            args['message'] = render_to_string('success.html', args)
            args['success'] = True
            return args
        else:
            args['message'] = render_to_string('fail.html')
            return args
    elif redirect_url:
         from django.views.generic.simple import redirect_to
         redirect_to(request, redirect_url)
    else:  
        raise Http404
Example #13
0
def FusionFlickrNew(request, flickrid):
    try:
        now = imagefromflickrid(flickrid, request.user)
    except ValidationError:
        return redirect_to(request, reverse('incorrect_license'))
    
    #return redirect_to(request, '/fusion/new/%d?init=true' % now.id)
    return redirect_to(request, reverse('fusion_new', args=[now.id]) + '?init=true')
Example #14
0
def logout(request):
    auth_logout(request)
    if 'next' in request.GET and request.GET['next']:
        return redirect_to(request, request.GET['next'], permanent=False)
    elif 'next' in request.POST and request.POST['next']:
        return redirect_to(request, request.POST['next'], permanent=False)
    else:
        return redirect_to(request, '/', permanent=False)
Example #15
0
def index(request):
    if request.user.is_authenticated():
        return redirect_to(request,
                           '/projeto/Tarefa/listar/', {},
                           context_instance=RequestContext(request))
    else:
        return redirect_to(request,
                           '/login/', {},
                           context_instance=RequestContext(request))
Example #16
0
def FusionFlickrNew(request, flickrid):
    try:
        now = imagefromflickrid(flickrid, request.user)
    except ValidationError:
        return redirect_to(request, reverse('incorrect_license'))

    #return redirect_to(request, '/fusion/new/%d?init=true' % now.id)
    return redirect_to(request,
                       reverse('fusion_new', args=[now.id]) + '?init=true')
Example #17
0
def tickets(request):
    if not request.user.is_authenticated():
        form = LoginForm()
        message = "Please log in to continue."
        return direct_to_template(request,
                'registration/login.html', {'form': form,
                'message': message})
    if request.method == 'POST':
        if request.POST.get('action', '') == 'transfer':
            email = request.POST.get('email', '')
            ticket_id = request.POST.get('ticket_id', '')
            ticket = Ticket.objects.get(pk=ticket_id)
            if ticket.purchase.user != request.user:
                return direct_to_template(request, 'texas/error.html',
                        {'message': "Access denied"})
            else:
                try:
                    assigned_user = User.objects.get(email__iexact=email)
                except:
                    assigned_user = None

                if not assigned_user:
                    assigned_user = User.objects.create_user(username=email,
                            email=email, password='')
                    assigned_user.first_name = ''.join(Random().sample(
                            string.letters+string.digits, 5))
                    assigned_user.is_active = False
                    assigned_user.save()

                ticket.assigned_user = assigned_user
                ticket.waiver = None
                #ticket.set_code()
                ticket.save()
                do_send_transfer_notification(ticket)
                return redirect_to(request, '/tickets/')

    paid_purchases = Purchase.objects.filter(
            user=request.user, status='P'
    ).exclude(
            occurrence__end_date__lte=datetime.now()
    )
    assigned_tickets = Ticket.objects.filter(
            assigned_user=request.user, purchase__status='P'
    ).exclude(
            purchase__occurrence__end_date__lte=datetime.now()
    )

    for ticket in assigned_tickets:
        if ticket.purchase.occurrence.event.waiver and not ticket.waiver:
            # break on the first one found
            return redirect_to(request, '/tickets/waiver/%s/' % ticket.id)

    return direct_to_template(request, 'texas/tickets.html',
            {'paid_purchases': paid_purchases,
                    'assigned_tickets': assigned_tickets})
Example #18
0
def edit_view(request, name=None):
    view = None
    if name:
        view = get_object_or_404(View, shortname=name)
    
    if request.method == "POST":
        form = ViewForm(request.user, request.POST, instance=view, prefix='view')
        if form.is_valid():
            
            if not view:
                # new view
                view = form.save(commit=False)
                view.creator = request.user
                view.save()
                form.save_m2m()
            else:
                form.save()
            
            queryformset = QueryFormSet(request.POST, instance=view, prefix='queries')
            queries_valid = queryformset.is_valid()
            if queries_valid:
                queryformset.saved_forms = []
                queryformset.save_existing_objects()
                queries = queryformset.save_new_objects(commit=False)
                for query in queries:
                    query.creator = request.user
                    query.save()
                    
            mappingformset = TagMappingFormSet(request.POST, instance=view, prefix='mappings')
            mappings_valid = mappingformset.is_valid()
            if mappings_valid:
                mappingformset.saved_forms = []
                mappingformset.save_existing_objects()
                mappings = mappingformset.save_new_objects(commit=False)
                for mapping in mappings:
                    mapping.creator = request.user
                    mapping.save()
            
            if queries_valid and mappings_valid:       
                if 'action' in request.POST and request.POST['action'] == 'add_row':
                    return redirect_to(request, reverse('openresources_edit_view', kwargs={'name':view.shortname}))               
                else:
                    return redirect_to(request, reverse('openresources_view', kwargs={'name':view.shortname}))               
        else:
            queryformset = QueryFormSet(instance=view, prefix='queries')
            mappingformset = TagMappingFormSet(instance=view, prefix='mappings')
    else:
        form = ViewForm(request.user, instance=view, prefix='view')
        queryformset = QueryFormSet(instance=view, prefix='queries')
        mappingformset = TagMappingFormSet(instance=view, prefix='mappings')
    
    popular_tags = Tag.objects.values('key').annotate(key_count=Count('key')).filter(key_count__gt=2).order_by('key')
    tag_help = settings.TAG_HELP_LINKS

    return render_to_response('openresources/view_edit.html', RequestContext(request, locals()))
Example #19
0
def logged_in(request):
    
    if request.user.is_staff:
        return redirect_to(request, reverse('patients_list'))
    
    if request.user.is_authenticated():
        p = request.user.get_profile()
        if p.is_profile_complete():
            return redirect_to(request, reverse('dashboard'))
        else:
            return redirect_to(request, reverse('complete_profile'))
Example #20
0
def edit_with_template(request, resource=None, template=None):

    if resource and not isinstance(resource, Resource):
        resource = get_object_or_404(Resource, shortname=resource)

    if template and not isinstance(template, ResourceTemplate):
        template = get_object_or_404(ResourceTemplate, shortname=template)

    key_choices = Tag.objects.values('key').annotate(key_count=Count('key')).filter(key_count__gt=2).order_by('key')
    key_choices = [(val['key'], val['key']) for val in key_choices]

    if request.method == "POST":
        form = ResourceForm(request.user, request.POST, request.FILES, instance=resource)
        if form.is_valid():
            
            if not resource:
                # new resource
                resource = form.save(commit=False)
                resource.creator = request.user
                resource.save()
                form.save_m2m()
            else:
                form.save()

            # we have to wait until here to create the formset to be able to assign the instance
            formset = TemplateFormSet(template, request.POST, request.FILES, instance=resource,
                                        can_delete=request.user.has_perm('openresources.delete_tag'),
                                        key_choices=key_choices)

            if formset.is_valid():     
         
                formset.saved_forms = []
                formset.save_existing_objects()
                tags = formset.save_new_objects(commit=False)
                for tag in tags:
                    tag.creator = request.user
                    tag.save()

            if 'action' in request.POST and request.POST['action'] == 'add_tag':
                return redirect_to(request, reverse('openresources_edit_with_template', kwargs={'resource':resource.shortname, 'template':template.shortname}))               
            else:

                return redirect_to(request, reverse('openresources_resource', kwargs={'key':resource.shortname}))               
    else:
        if template and not resource:
            # pre-initialize template field for new resources
            form = ResourceForm(request.user, initial={'template':template})
        else:
            form = ResourceForm(request.user, instance=resource)
        formset = TemplateFormSet(template, instance=resource, can_delete=request.user.has_perm('openresources.delete_tag'), key_choices=key_choices)
    
    return render_to_response('openresources/edit_with_template.html', RequestContext(request, locals()))
Example #21
0
def bid_history(request, auction_id):
    auction = get_object_or_404(Auction, pk=auction_id)
    
    user_membership = auction.asset.period.world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    # if our period hasn't started yet, don't show the info.
    if not auction.asset.period.is_started() and not user_membership.is_master:
        request.user.message_set.create(message = "Period " + unicode(auction.asset.period.number) + " of World " + auction.asset.period.world.name + " has not yet started.")
        return redirect_to(request, url ='/thegame/userprofile/')
    else:
        return render_to_response('bid_history.html', {'auction':auction, 'user_membership':user_membership}, context_instance=RequestContext(request))
Example #22
0
def period_detail(request, world_id, period_id):
    period = get_object_or_404(Period, pk=period_id)
    world = get_object_or_404(World, pk=world_id)
    
    user_membership = world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')

    # if our period hasn't started yet, don't show the info.
    if not period.is_started() and not user_membership.is_master:
        request.user.message_set.create(message = "Period " + unicode(period.number) + " of World " + world.name + " has not yet started.")
        return redirect_to(request, url ='/thegame/userprofile/')

    return render_to_response('period_detail.html', {'period':period, 'world':world, 'user_membership':user_membership}, context_instance=RequestContext(request))
Example #23
0
def expensevoucher_add(request, **kwargs):
    """Adds a new expensevoucher.
    """
    expensevoucher = ExpenseVoucher(date=datetime.now().date())
    doc = Document(author=request.user, content_object=expensevoucher)

    if request.method == 'POST':
        dform = DocumentForm(request.POST, instance=doc)
        form = ExpenseVoucherForm(request.POST, instance=expensevoucher)
        formset = ExpenseEntryFormset(request.POST, instance=expensevoucher)
        if form.is_valid() and dform.is_valid() and formset.is_valid():
            form.save()
            doc.content_object = expensevoucher
            dform.save()
            formset.save()
            messages.success(
                request, _("The expense voucher was created successfully."))
            return redirect_to(request, url=doc.get_absolute_url())
    else:
        dform = DocumentForm(instance=doc)
        form = ExpenseVoucherForm(instance=expensevoucher)
        formset = ExpenseEntryFormset(instance=expensevoucher)

    return render_to_response(
        'hr/expensevoucher_edit.html',
        RequestContext(request, {
            'form': form,
            'dform': dform,
            'formset': formset,
            'object': doc
        }))
Example #24
0
def warehouse_add_outgoing_movement(request, id, **kwargs):
    """Adds a new movement from the given warehouse.
    """
    movement = Movement(origin_id=id, author=request.user)

    if request.method == 'POST':
        form = OutgoingMovementForm(request.POST, instance=movement)
        pform = ProductEntryForm(request.POST)
        if pform.is_valid() and form.is_valid():
            pe = pform.save()
            movement.product_entry = pe
            form.save()
            messages.success(request,
                             _("The movement was created successfully."))
            return redirect_to(request, url=movement.get_absolute_url())
    else:
        form = OutgoingMovementForm(instance=movement)
        pform = ProductEntryForm()

    return render_to_response(
        'stock/warehouse_edit_movement.html',
        RequestContext(request, {
            'form': form,
            'pform': pform,
            'object': movement
        }))
Example #25
0
def bookmark_add(request, username, **kwargs):
    """Adds a new bookmark for the current user.
    """
    user = get_object_or_404(User, username=username)

    bookmarks = user.get_profile().bookmarks
    bookmark = Bookmark(menu=bookmarks, sort_order=bookmarks.links.count())

    if request.method == 'POST':
        form = BookmarkForm(request.POST, instance=bookmark)
        if form.is_valid():
            bookmark.slug = slugify("%s_%s" % (bookmark.title, user.pk))
            bookmark = form.save()
            messages.success(request,
                             _("The bookmark was created successfully."))
            return redirect_to(request,
                               url=reverse('bookmark_list',
                                           args=[user.username]))
    else:
        url = clean_referer(request)
        if url == reverse('bookmark_list', args=[user.username]):
            url = ""
        bookmark.url = url
        form = BookmarkForm(instance=bookmark)

    return render_to_response(
        'menus/bookmark_edit.html',
        RequestContext(request, {
            'form': form,
            'object': bookmark,
            'object_user': user
        }))
Example #26
0
def search(request, query_string="", page=0, paginate_by=10, **kwargs):
    """Displays the list of results for the current search query.
    """
    if ('q' in request.GET) and request.GET['q'].strip():
        query_string = request.GET['q']
        return redirect_to(
            request,
            reverse('search_with_query', args=[query_string.replace(' ',
                                                                    '+')]))

    Result.objects.all().delete()
    if query_string:
        autodiscover()
        for model, fields in MODELS.items():
            q = _get_query(query_string, [field.name for field in fields])
            objects = model.objects.filter(q)
            for obj in objects:
                r = Result(title=obj, content_object=obj)
                r.save()
    else:
        messages.error(request, _("Please, specify a valid search query."))

    return list_detail.object_list(
        request,
        queryset=Result.objects.all(),
        paginate_by=paginate_by,
        page=page,
        template_name="taxonomy/search.html",
        extra_context={'query': query_string.replace('+', ' ')},
        **kwargs)
Example #27
0
def editar_suplemento_dia(request, contrato_id, id=None):
    """Los suplementos por día"""
    name = "Suplementos por día"
    contrato = Contrato.objects.get(pk=contrato_id)
    form = SuplementoDiaForm(
        request.POST or None,
        instance=id
        and SuplementoDia.objects.get(id=id, contrato__id=contrato_id))
    if request.method == 'POST':
        form.instance.contrato = contrato
        if form.is_valid():
            condicion = form.save(commit=False)
            condicion.contrato = contrato
            condicion.save()
            return redirect_to(request,
                               url=reverse('contrato-hotel',
                                           args=[
                                               contrato.hotel.slug,
                                           ]))
    return direct_to_template(request,
                              template='motor/condiciones_contrato.html',
                              extra_context={
                                  'form': form,
                                  'contrato': contrato,
                                  'name': name
                              })
Example #28
0
def world_detail_master(request, world_id):
    # world attributes/settings edit form, prefilled
    # list periods, with edit/delete links, create new button
    # list users, with approve/delete/edit links, create new button
    world = get_object_or_404(World, pk=world_id)
    user_membership = world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    if not user_membership.is_master:
        request.user.message_set.create(message = 'You are not authorized to edit this world.')
        return HttpResponseRedirect(world.get_absolute_url())
    
    world_form = WorldForm(instance = world)
    
    # could this ever error if a user is created in the middle, thus creating
    # an unequal number of items in formset and queryset?
    membership_queryset = Membership.objects.filter(world = world).order_by('user__user__username')
    user_formset = MembershipFormSet(queryset = membership_queryset)
    user_formset_dict = dict(zip(membership_queryset, user_formset.forms))
    
        
    return render_to_response('world_detail_master.html', 
            {'world_form':world_form, 
            'user_formset':user_formset, 
            'user_formset_dict': user_formset_dict, 
            'world':world,
            'user_membership':user_membership,}, 
            context_instance=RequestContext(request))
Example #29
0
def period_detail_master(request, world_id, period_id):
    # period attributes edit form, prefilled
    # list asset-auctions, with edit/delete links, create new button
    period = get_object_or_404(Period, pk=period_id)
    world = get_object_or_404(World, pk=world_id)
    
    user_membership = world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    if not user_membership.is_master:
        request.user.message_set.create(message = 'You are not authorized to edit this world.')
        return HttpResponseRedirect(period.get_absolute_url())
    
    q = World.objects.filter(membership__user__user = request.user)
    
    if request.method == 'POST': # If the form has been submitted...
        period_form = PeriodForm(request.POST, instance=period, queryset = q) # A form bound to the POST data for asset
        if period_form.is_valid():
            new_period = period_form.save()
            
            request.user.message_set.create(message = "Period edited successfully.")
            return HttpResponseRedirect('.')
    else:
        period_form = PeriodForm(instance = period, queryset = q)
    
    membership_queryset = Membership.objects.filter(world = world).order_by('user__user__username')
    period_bids = Bid.objects.filter(auction__asset__period=period)
    
    return render_to_response('period_detail_master.html', {'period':period, 'world':world, 'user_membership':user_membership, 'period_form':period_form, 'world_members':membership_queryset, 'period_bids':period_bids}, context_instance=RequestContext(request))
Example #30
0
def employee_add(request, **kwargs):
    """Adds a new employee.
    """
    job = Job()
    employee = Employee()
      
    if request.method == 'POST':
        jform = JobForm(request.POST, instance=job)
        form = EmployeeForm(request.POST, instance=employee)
        if jform.is_valid():
            jform.save()
            employee = job.employee
            form = EmployeeForm(request.POST, instance=employee)
            if form.is_valid():
                form.save()
                messages.success(request, _("The employee was created successfully."))
                return redirect_to(request, url=employee.get_absolute_url())
            else:
                job.delete()
                jform = JobForm(instance=job)
                form = EmployeeForm(instance=employee)
    else:
        jform = JobForm(instance=job)
        form = EmployeeForm(instance=employee)

    return render_to_response('hr/employee_edit.html', RequestContext(request, {'form': form, 'jform': jform, 'object': employee}))
Example #31
0
def editar_suplemento_regimen(request, hotel_id, id=None):
    """Los suplementos de regimen van por hotel"""
    name = "Suplementos de Régimen"
    hotel = Hotel.objects.get(pk=hotel_id)
    form = SuplementoRegimenForm(
        request.POST or None,
        instance=id
        and SuplementoRegimen.objects.get(id=id, hotel__id=hotel_id))
    if request.method == 'POST':
        form.instance.hotel = hotel
        if form.is_valid():
            condicion = form.save(commit=False)
            condicion.hotel = hotel
            condicion.save()
            return redirect_to(request,
                               url=reverse('contrato-hotel',
                                           args=[
                                               hotel.slug,
                                           ]))
    return direct_to_template(request,
                              template='motor/condiciones_contrato.html',
                              extra_context={
                                  'form': form,
                                  'name': name
                              })
Example #32
0
def editar_descuento_ninyos(request, contrato_id, id=None):
    """Descuento niños"""
    name = "Descuento Niños"
    contrato = Contrato.objects.get(pk=contrato_id)
    form = DescuentoNinyosForm(
        request.POST or None,
        instance=id
        and DescuentoNin.objects.get(id=id, contrato__id=contrato_id))
    if request.method == 'POST':
        form.instance.contrato = contrato
        if form.is_valid():
            condicion = form.save(commit=False)
            condicion.contrato = contrato
            condicion.save()
            return redirect_to(request,
                               url=reverse('contrato-hotel',
                                           args=[
                                               contrato.hotel.slug,
                                           ]))
    return direct_to_template(request,
                              template='motor/condiciones_contrato.html',
                              extra_context={
                                  'form': form,
                                  'contrato': contrato,
                                  'name': name
                              })
Example #33
0
def editar_condiciones(request, contrato_id, id=None):
    """Modificación y alta de la cabecera de un contrato"""
    name = "Condiciones del Contrato"
    contrato = Contrato.objects.get(pk=contrato_id)
    form = CondicionesContratoForm(
        request.POST or None,
        instance=id
        and CondicionesContrato.objects.get(id=id, contrato__id=contrato_id))
    if request.method == 'POST':
        form.instance.contrato = contrato
        if form.is_valid():
            condicion = form.save(commit=False)
            condicion.contrato = contrato
            condicion.save()
            return redirect_to(request,
                               url=reverse('contrato-hotel',
                                           args=[
                                               contrato.hotel.slug,
                                           ]))
    return direct_to_template(request,
                              template='motor/condiciones_contrato.html',
                              extra_context={
                                  'form': form,
                                  'contrato': contrato,
                                  'name': name
                              })
Example #34
0
def editar_restriccion_blackout(request, contrato_id, id=None):
    """Restriccion de blackout"""
    name = "Restricción de Blackout"
    contrato = Contrato.objects.get(pk=contrato_id)
    form = RestriccionBlackoutForm(
        request.POST or None,
        instance=id
        and RestriccionBlackout.objects.get(id=id, contrato__id=contrato_id))
    if request.method == 'POST':
        form.instance.contrato = contrato
        if form.is_valid():
            condicion = form.save(commit=False)
            condicion.contrato = contrato
            condicion.save()
            return redirect_to(request,
                               url=reverse('contrato-hotel',
                                           args=[
                                               contrato.hotel.slug,
                                           ]))
    return direct_to_template(request,
                              template='motor/condiciones_contrato.html',
                              extra_context={
                                  'form': form,
                                  'contrato': contrato,
                                  'name': name
                              })
Example #35
0
def salesinvoice_add(request, **kwargs):
    """Adds a new sales invoice.
    """
    salesinvoice = SalesInvoice()
    doc = Document(author=request.user, content_object=salesinvoice)

    if request.method == 'POST':
        dform = DocumentForm(request.POST, instance=doc)
        form = SalesInvoiceForm(request.POST, instance=salesinvoice)
        formset = ProductEntryFormset(request.POST)
        if form.is_valid() and dform.is_valid() and formset.is_valid():
            form.save()
            doc.content_object = salesinvoice
            dform.save()
            for e in formset.save():
                salesinvoice.entries.add(e)
            messages.success(request,
                             _("The sales invoice was created successfully."))
            return redirect_to(request, url=doc.get_absolute_url())
    else:
        dform = DocumentForm(instance=doc)
        form = SalesInvoiceForm(instance=salesinvoice)
        formset = ProductEntryFormset()

    return render_to_response(
        'sales/salesinvoice_edit.html',
        RequestContext(request, {
            'form': form,
            'dform': dform,
            'formset': formset,
            'object': doc
        }))
Example #36
0
def event_add(request, year=None, month=None, day=None, **kwargs):
    """Adds a new event.
    """
    start = datetime.datetime.now()
    if year and month and day:
        start = datetime.datetime.combine(
            datetime.date(int(year), int(month), int(day)), start.time())

    event = Event(author=request.user, start=start)

    if request.method == 'POST':
        form = EventForm(request.POST, instance=event)
        if form.is_valid():
            form.save()
            event.calendars.add(request.user.get_profile().calendar)
            messages.success(request, _("The event was created successfully."))
            return redirect_to(request, url=event.get_absolute_url())
    else:
        form = EventForm(instance=event)

    return render_to_response(
        'calendar/event_edit.html',
        RequestContext(request, {
            'form': form,
            'object': event
        }))
Example #37
0
def period_results_master(request, world_id, period_id):
    # button to regenerate period results
    
    period = get_object_or_404(Period, pk=period_id)
    world = get_object_or_404(World, pk=world_id)
    
    user_membership = world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    if not user_membership.is_master:
        request.user.message_set.create(message = 'You are not authorized to edit this world.')
        return HttpResponseRedirect(period.get_absolute_url())
    
    # if our period hasn't completed yet, don't show the info.
    if not period.is_ended():
        request.user.message_set.create(message = "Period " + unicode(period.number) + " of World " + world.name + " is not yet complete.")
        return HttpResponseRedirect(request.user.get_profile().get_absolute_url())
    
    if request.method == 'POST': # If the form has been submitted...
        form = RecalculatePeriodResultsForm(request.POST)
        if form.is_valid():
            #period.recalc_period_summary(form.cleaned_data['update_wealth'])
            period.calc_period_summary(force=True, 
                    recalc_auctions = form.cleaned_data['recalc_auctions'])
            request.user.message_set.create(message = "Results recalculated.")
            return HttpResponseRedirect('.')
        else: 
            request.user.message_set.create(message = "Form errors.")
    else:
        form = RecalculatePeriodResultsForm()
    
    period_result_list = period.periodsummary_set.all().order_by('-correct_count')
    return render_to_response('period_results_master.html', {'period':period, 'world':world, 'user_membership':user_membership, 'period_result_list':period_result_list, 'form':form}, context_instance=RequestContext(request))
Example #38
0
    def add_view(self, request, form_url="", extra_context=None):
        model = self.model
        opts = model._meta

        if request.method == "POST":
            if "cancel" in request.POST:
                return redirect_to(request, reverse("admin:materials_library_changelist"))
            form = LibraryAddForm(request.POST, initial=dict(creator=request.user))
            authors_formset = AuthorsFormSet(request.POST, prefix="authors", queryset=Author.objects.none())
            if form.is_valid() and authors_formset.is_valid():
                obj = form.save()
                saved_authors = authors_formset.save()
                # TODO: reindex all related objects if author info were changed
                for author in saved_authors:
                    obj.authors.add(author)
                obj.save()
                return self.response_add(request, obj)
        else:
            form = LibraryAddForm(initial=dict(creator=request.user))
            authors_formset = AuthorsFormSet(prefix="authors", queryset=Author.objects.none())

        context = {
            "title": _("Add %s") % force_unicode(opts.verbose_name),
            "form": form,
            "authors_formset": authors_formset,
            "main_fields": MAIN_FIELDS_CHANGE,
            "is_popup": request.REQUEST.has_key("_popup"),
            "show_delete": False,
            "app_label": opts.app_label,
            "media": mark_safe(
                self.media + forms.Media(js=["%s%s" % (settings.ADMIN_MEDIA_PREFIX, "js/collapse.min.js")])
            ),
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, form_url=form_url, add=True)
Example #39
0
    def add_view(self, request, form_url='', extra_context=None):
        model = self.model
        opts = model._meta

        if request.method == "POST":
            if "cancel" in request.POST:
                return redirect_to(request, reverse("admin:materials_course_changelist"))
            form = CourseAddForm(request.POST, initial=dict(creator=request.user))
            authors_formset = AuthorsFormSet(request.POST, prefix="authors", queryset=Author.objects.none())
            if form.is_valid() and authors_formset.is_valid():
                obj = form.save()
                saved_authors = authors_formset.save()
                # TODO: reindex all related objects if author info were changed
                for author in saved_authors:
                    obj.authors.add(author)
                obj.save()
                return self.response_add(request, obj)
        else:
            form = CourseAddForm(initial=dict(creator=request.user))
            authors_formset = AuthorsFormSet(prefix="authors", queryset=Author.objects.none())

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'form': form,
            'authors_formset': authors_formset,
            'main_fields': MAIN_FIELDS_CHANGE,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'app_label': opts.app_label,
            'media': mark_safe(self.media + forms.Media(js=['%s%s' % (settings.ADMIN_MEDIA_PREFIX, 'js/collapse.min.js')])),
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, form_url=form_url, add=True)
Example #40
0
def getCreateMyGridPage(request):
    if not request.user.is_authenticated():
        return redirect_to(request, '/auth/login/')
    try:
        tableOnly= False
        if request.REQUEST.has_key('tableOnly'):
            if request.REQUEST['tableOnly'] == 'true':
                tableOnly= True
    
        gridTableTemplate= GridTableData(generateGridTable(None))
        gridTableTemplate.changeRatingsWeights= True
        gridTableTemplate.changeCornAlt= True
        gridTableTemplate.tableId= randomStringGenerator()
             
        context= None 
        #RequestContext(request, {'data': gridTableTemplate })
        if tableOnly:
            template= loader.get_template('gridMng/createMyGridBase.html')
            templateData= CreateMyGridBaseData(gridTableTemplate)
            context= RequestContext(request, {'data': templateData })
            htmlData= template.render(context)
            return HttpResponse(createXmlSuccessResponse(htmlData), content_type='application/xml')
        else:
            templateData= CreateMyGridData(CreateMyGridBaseData(gridTableTemplate))
            context= RequestContext(request, {'data': templateData })
            return render(request, 'gridMng/createMyGrid.html', context_instance=context)

    except:
        #do nothing
        print "Exception in user code:"
        print '-'*60
        traceback.print_exc(file=sys.stdout)
        print '-'*60
        return HttpResponse(createXmlErrorResponse('unknown error'), content_type='application/xml')
Example #41
0
def amazon_process(request):
    try:
        tid = request.GET.get('transactionId')
        pid = request.GET.get('referenceId')
        amt = request.GET.get('transactionAmount')
        name = request.GET.get('buyerName')

        purchase = Purchase.objects.get(pk=pid)
        if amt != "USD %s" % purchase.amount_due:
            return direct_to_template(request, 'texas/error.html',
                {'message': "Payment amount does not match!"})
        payment = Payment(purchase=purchase, amount=purchase.get_price(),
                reference=tid)
        payment.purchaser_name = name
        payment.save()
        if payment.amount >= purchase.amount_due:
            purchase.status = 'P'
            purchase.save()
            for ticket in purchase.ticket_set.all():
                ticket.assigned_name = payment.purchaser_name
                ticket.set_code()
                ticket.set_number()
            do_send_purchase_confirmation(purchase)
        return redirect_to(request, "/buy/purchases/receipt/%i/" % purchase.id)
        return direct_to_template(request, 'texas/error.html',
            {'message': "Payment error!"})
    except:
        return direct_to_template(request, 'texas/error.html',
            {'message': "Amazon payment error!  Please contact [email protected] and make a payment via PayPal.  We will refund your Amazon payment promptly if notified."})
Example #42
0
def auction_detail_master(request, auction_id):
    # auction edit form, prefilled
    # list bids, with delete links? or do that in bid history
    
    auction = get_object_or_404(Auction, pk=auction_id)
    
    user_membership = auction.asset.period.world.user_is_member(request.user)
    if not user_membership:
        request.user.message_set.create(message = "Access denied. Either you are not a member of the world requested, or your membership has not yet been approved.")
        return redirect_to(request, url ='/thegame/userprofile/')
    
    if not user_membership.is_master:
        request.user.message_set.create(message = 'You are not authorized to edit this world.')
        return HttpResponseRedirect(auction.get_absolute_url())
    
    if request.method == 'POST': # If the form has been submitted...
        asset_form = AssetForm(request.POST, instance=auction.asset, queryset = auction.asset.period.world.period_set.all()) # A form bound to the POST data for asset
        auction_form = AuctionForm(request.POST, instance=auction) # A form bound to the POST data for auction
        if asset_form.is_valid() and auction_form.is_valid():
            new_asset = asset_form.save()
            new_auction = auction_form.save()
            
            request.user.message_set.create(message = "Auction edited successfully.")
            return HttpResponseRedirect('.')
        else:
            request.user.message_set.create(message = "Errors in form.")
    else:
        asset_form = AssetForm(instance = auction.asset, queryset = auction.asset.period.world.period_set.all())
        auction_form = AuctionForm(instance = auction)

    return render_to_response('auction_detail_master.html', {'auction':auction, 'user_membership':user_membership, 'asset_form':asset_form, 'auction_form':auction_form}, context_instance=RequestContext(request))
Example #43
0
def edit_tap(request, tap_id):
    context = RequestContext(request)
    tap = get_object_or_404(models.KegTap, site=request.kbsite, seqn=tap_id)
    form = forms.ChangeKegForm()

    form = forms.ChangeKegForm(request.POST)
    if form.is_valid():
        current = tap.current_keg
        if current and current.status != 'offline':
            current.status = 'offline'
            current.save()
        new_keg = models.Keg()
        new_keg.site = request.kbsite
        new_keg.type = form.cleaned_data['beer_type']
        new_keg.size = form.cleaned_data['keg_size']
        new_keg.status = 'online'
        if form.cleaned_data['description']:
            new_keg.description = form.cleaned_data['description']
        new_keg.save()
        tap.current_keg = new_keg
        tap.save()
        messages.success(request, 'The new keg was activated. Bottoms up!')
        form = forms.ChangeKegForm()

    result_url = reverse('kegadmin-taps', args=[request.kbsite.url()])
    return redirect_to(request, result_url)
Example #44
0
def timesheet_edit(request, id, **kwargs):
    """Edits a timesheet.
    """
    doc = Document.objects.get_for_content(Timesheet).get(object_id=id)
    timesheet = doc.content_object

    if request.method == 'POST':
        dform = DocumentForm(request.POST, instance=doc)
        form = TimesheetForm(request.POST, instance=timesheet)
        formset = TimesheetEntryFormset(request.POST, instance=timesheet)
        if form.is_valid() and dform.is_valid() and formset.is_valid():
            form.save()
            dform.save()
            formset.save()
            messages.success(request,
                             _("The timesheet was updated successfully."))
            return redirect_to(request, url=doc.get_absolute_url())
    else:
        dform = DocumentForm(instance=doc)
        form = TimesheetForm(instance=timesheet)
        formset = TimesheetEntryFormset(instance=timesheet)

    return render_to_response(
        'hr/timesheet_edit.html',
        RequestContext(request, {
            'form': form,
            'dform': dform,
            'formset': formset,
            'object': doc
        }))
Example #45
0
def render_to_pdf(request,
                  template_name,
                  context,
                  filename="report.pdf",
                  encoding='utf-8',
                  **kwargs):
    """Renders a pdf response using given *request*, *template_name* and *context*.
    """
    if not isinstance(context, Context):
        context = RequestContext(request, context)

    content = render_to_string(template_name, context)
    src = StringIO(content.encode(encoding))
    out = StringIO()
    result = pisa.CreatePDF(src,
                            out,
                            link_callback=fetch_resources,
                            encoding="UTF-8")

    if not result.err:
        response = HttpResponse(out.getvalue(), mimetype='application/pdf')
        if filename is not None:
            response[
                'Content-Disposition'] = 'attachment; filename=%s' % filename
        return response

    messages.error(request,
                   _("An error has occurred during the PDF conversion"))

    return redirect_to(request, url=clean_referer(request))
Example #46
0
def static_serve(request, path, client):
    """
    Given a request for a media asset, this view does the necessary wrangling
    to get the correct thing delivered to the user. This can also emulate the
    combo behavior seen when SERVE_REMOTE == False and EMULATE_COMBO == True.
    """
    if msettings["SERVE_REMOTE"]:
        # We're serving from S3, redirect there.
        url = client.remote_media_url().strip("/") + "/%(path)s"
        return redirect_to(request, url, path=path)

    if not msettings["SERVE_REMOTE"] and msettings["EMULATE_COMBO"]:
        # Combo emulation is on and we're serving media locally. Try to see if
        # the given path matches a combo file defined in the JOINED dict in
        # the MEDIASYNC settings dict.
        combo_match = _find_combo_match(path)
        if combo_match:
            # We found a combo file match. Combine it and serve the result.
            return combo_serve(request, combo_match, client)

    # No combo file, but we're serving locally. Use the standard (inefficient)
    # Django static serve view.
    resp = serve(request, path, document_root=client.media_root)
    resp.content = client.process(resp.content, resp["Content-Type"], path)
    return resp
Example #47
0
def revert_to_revision(request,
                       title,
                       group_slug=None,
                       bridge=None,
                       article_qs=ALL_ARTICLES,
                       extra_context=None,
                       is_member=None,
                       is_private=None,
                       *args,
                       **kw):

    if request.method == 'POST':

        revision = int(request.POST['revision'])

        article_args = {'title': title}

        group = None
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            # @@@ use bridge instead
            article_args.update({
                'content_type': get_ct(group),
                'object_id': group.id
            })
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            group = None
            allow_read = allow_write = True
            article_args.update({'object_id': None})

        if not (allow_read or allow_write):
            return HttpResponseForbidden()

        article = get_object_or_404(article_qs, **article_args)

        if request.user.is_authenticated():
            article.revert_to(revision, get_real_ip(request), request.user)
        else:
            article.revert_to(revision, get_real_ip(request))

        if request.user.is_authenticated():
            request.user.message_set.create(
                message=u"The article was reverted successfully.")

        url = get_url('wiki_article_history',
                      group,
                      kw={
                          'title': title,
                      },
                      bridge=bridge)

        return redirect_to(request, url)

    return HttpResponseNotAllowed(['POST'])
Example #48
0
def address_add(request,
                owner,
                post_save_redirect,
                template_name,
                owner_field='addresses',
                **kwargs):
    """Adds a new address to the given owner.
    """
    if request.method == 'POST':
        form = AddressForm(request.POST)
        if form.is_valid():
            instance = form.save()
            rel, value = _get_field_and_value(owner, owner_field)
            if isinstance(rel, models.ForeignKey):
                setattr(owner, owner_field, instance)
            elif isinstance(rel, models.ManyToManyField):
                value.add(instance)
            owner.save()
            if owner.pk:
                messages.success(
                    request,
                    _("Address added to %(owner)s") % {'owner': owner})
            return redirect_to(request, url=post_save_redirect)
    else:
        form = AddressForm()

    context = {'owner': owner, 'form': form}
    if 'extra_context' in kwargs:
        context.update(kwargs['extra_context'])

    return render_to_response(template_name, RequestContext(request, context))
Example #49
0
def ticket_edit(request, project, code, **kwargs):
    """Edits a ticket.
    """
    project = get_object_or_404(Project, code=project)
    ticket = get_object_or_404(Ticket, project=project, code=code)
    if request.method == 'POST':
        form = TicketForm(request.POST, instance=ticket)
        if form.is_valid():
            ticket = form.save()
            messages.success(request,
                             _("The ticket was updated successfully."))
            return redirect_to(request, url=ticket.get_absolute_url())
    else:
        form = TicketForm(instance=ticket)

    if not request.user.has_perm("projects.change_milestone"):
        del form.fields['milestone']

    if not request.user.has_perm("projects.change_assignee"):
        del form.fields['assignee']

    return render_to_response(
        'projects/ticket_edit.html',
        RequestContext(request, {
            'form': form,
            'object': ticket
        }))
Example #50
0
def bookmark_edit(request, username, slug, **kwargs):
    """Edits an existing bookmark for the current user.
    """
    user = get_object_or_404(User, username=username)

    bookmarks = user.get_profile().bookmarks
    bookmark = get_object_or_404(Bookmark, menu=bookmarks, slug=slug)

    if request.method == 'POST':
        form = BookmarkForm(request.POST, instance=bookmark)
        if form.is_valid():
            bookmark = form.save()
            messages.success(request,
                             _("The bookmark was updated successfully."))
            return redirect_to(request,
                               url=reverse('bookmark_list',
                                           args=[user.username]))
    else:
        form = BookmarkForm(instance=bookmark)

    return render_to_response(
        'menus/bookmark_edit.html',
        RequestContext(request, {
            'form': form,
            'object': bookmark,
            'object_user': user
        }))
Example #51
0
def ticket_add(request, project, milestone=None, **kwargs):
    """Adds a new ticket.
    """
    project = get_object_or_404(Project, code=project)
    ticket = Ticket(project=project, author=request.user)

    initial = {}

    if milestone is not None:
        milestone = get_object_or_404(Milestone,
                                      code=milestone,
                                      project=project)
        initial['milestone'] = milestone

    if request.method == 'POST':
        form = TicketForm(request.POST, instance=ticket, initial=initial)
        if form.is_valid():
            ticket = form.save()
            messages.success(request, _("Your ticket has been registered."))
            return redirect_to(request, url=ticket.get_absolute_url())
    else:
        form = TicketForm(instance=ticket, initial=initial)

    if not request.user.has_perm("projects.change_milestone"):
        del form.fields['milestone']

    if not request.user.has_perm("projects.change_assignee"):
        del form.fields['assignee']

    return render_to_response(
        'projects/ticket_edit.html',
        RequestContext(request, {
            'form': form,
            'object': ticket
        }))
Example #52
0
def edit_tap(request, tap_id):
  context = RequestContext(request)
  tap = get_object_or_404(models.KegTap, site=request.kbsite, seqn=tap_id)
  form = forms.ChangeKegForm()

  form = forms.ChangeKegForm(request.POST)
  if form.is_valid():
    current = tap.current_keg
    if current and current.status != 'offline':
      current.status = 'offline'
      current.save()
    new_keg = models.Keg()
    new_keg.site = request.kbsite
    new_keg.type = form.cleaned_data['beer_type']
    new_keg.size = form.cleaned_data['keg_size']
    new_keg.status = 'online'
    if form.cleaned_data['description']:
      new_keg.description = form.cleaned_data['description']
    new_keg.save()
    tap.current_keg = new_keg
    tap.save()
    messages.success(request, 'The new keg was activated. Bottoms up!')
    form = forms.ChangeKegForm()

  result_url = reverse('kegadmin-taps', args=[request.kbsite.url()])
  return redirect_to(request, result_url)
Example #53
0
def salesinvoice_edit(request, id, **kwargs):
    """Edits a sales invoice.
    """
    doc = get_object_or_404(Document.objects.get_for_content(SalesInvoice),
                            object_id=id)
    salesinvoice = doc.content_object

    if request.method == 'POST':
        dform = DocumentForm(request.POST, instance=doc)
        form = SalesInvoiceForm(request.POST, instance=salesinvoice)
        formset = ProductEntryFormset(request.POST,
                                      queryset=salesinvoice.entries.all())
        if form.is_valid() and dform.is_valid() and formset.is_valid():
            form.save()
            dform.save()
            for e in formset.save():
                salesinvoice.entries.add(e)
            messages.success(request,
                             _("The sales invoice was updated successfully."))
            return redirect_to(request, url=doc.get_absolute_url())
    else:
        dform = DocumentForm(instance=doc)
        form = SalesInvoiceForm(instance=salesinvoice)
        formset = ProductEntryFormset(queryset=salesinvoice.entries.all())

    return render_to_response(
        'sales/salesinvoice_edit.html',
        RequestContext(request, {
            'form': form,
            'dform': dform,
            'formset': formset,
            'object': doc
        }))
Example #54
0
def page_edit(request, slug=None, **kwargs):
    """Edits or creates a page.
    """
    try:
        page = WikiPage.objects.get(slug=slug)
    except WikiPage.DoesNotExist:
        page = WikiPage(slug=slug,
                        author=request.user,
                        language=request.user.get_profile().language)

    if request.method == 'POST':
        form = WikiPageForm(request.POST, instance=page)
        if form.is_valid():
            is_new = (not page.pk)
            form.save()
            if is_new:
                messages.success(request,
                                 _("The page was created successfully."))
            else:
                messages.success(request,
                                 _("The page was updated successfully."))
            return redirect_to(request, url=page.get_absolute_url())
    else:
        form = WikiPageForm(instance=page)

    return render_to_response(
        'knowledge/wikipage_edit.html',
        RequestContext(request, {
            'form': form,
            'object': page
        }))
Example #55
0
def expensevoucher_edit(request, id, **kwargs):
    """Edits a expensevoucher.
    """
    doc = Document.objects.get_for_content(ExpenseVoucher).get(object_id=id)
    expensevoucher = doc.content_object

    if request.method == 'POST':
        dform = DocumentForm(request.POST, instance=doc)
        form = ExpenseVoucherForm(request.POST, instance=expensevoucher)
        formset = ExpenseEntryFormset(request.POST, instance=expensevoucher)
        if form.is_valid() and dform.is_valid() and formset.is_valid():
            form.save()
            dform.save()
            formset.save()
            messages.success(
                request, _("The expense voucher was updated successfully."))
            return redirect_to(request, url=doc.get_absolute_url())
    else:
        dform = DocumentForm(instance=doc)
        form = ExpenseVoucherForm(instance=expensevoucher)
        formset = ExpenseEntryFormset(instance=expensevoucher)

    return render_to_response(
        'hr/expensevoucher_edit.html',
        RequestContext(request, {
            'form': form,
            'dform': dform,
            'formset': formset,
            'object': doc
        }))
Example #56
0
def ajaxGenerateDendogram(request):
    if not request.user.is_authenticated():
        return redirect_to(request, '/auth/login/')
    if request.POST.has_key('gridUSID'):
        grid1= Grid.objects.filter(user= request.user, usid= request.POST['gridUSID'])
        if len(grid1) >= 1:
            try:
                grid1= grid1[0]
                if grid1.dendogram != None and grid1.dendogram != '':
                    return HttpResponse(grid1.dendogram, content_type='application/xml')
                else:
                    try:     
                        imgData= createDendogram(grid1)
                        return HttpResponse(imgData, content_type='application/xml')
                    except:
                        print "Exception in user code:"
                        print '-'*60
                        traceback.print_exc(file=sys.stdout)
                        print '-'*60
                        return HttpResponse(createXmlErrorResponse('Unknown dendrogram error'), content_type='application/xml')
            except:
                print "Exception in user code:"
                print '-'*60
                traceback.print_exc(file=sys.stdout)
                print '-'*60
                return HttpResponse(createXmlErrorResponse('Unknown error'), content_type='application/xml')
        else:
            return HttpResponse(createXmlErrorResponse('Could not find the grid to generate the dendrogram'), content_type='application/xml')
    else:
        return HttpResponse(createXmlErrorResponse('Invalid request, request is missing argument(s)'), content_type='application/xml')
Example #57
0
def user_edit(request, username, **kwargs):
    """Edits a user's profile.
    """
    user = get_object_or_404(User, username=username)

    if request.method == 'POST':
        form = UserEditForm(request.POST, instance=user)
        _adapt_form(request, form)
        pform = UserProfileForm(request.POST, instance=user.get_profile())
        if form.is_valid() and pform.is_valid():
            user = form.save()
            profile = pform.save()
            if request.user == user:
                set_language(request, profile.language)
            messages.success(request, _("The user was updated successfully."))
            return redirect_to(request, url=user.get_absolute_url())
    else:
        form = UserEditForm(instance=user)
        _adapt_form(request, form)
        pform = UserProfileForm(instance=user.get_profile())

    return render_to_response(
        'auth/user_edit.html',
        RequestContext(request, {
            'form': form,
            'pform': pform,
            'object': user
        }))
Example #58
0
def signin(request):
    try:
        next = request.POST['next']
    except KeyError:
        try:
            next = request.GET['next']
        except KeyError:
            next = SNAP_PREFIX

    if request.POST:
        form_data = request.POST.copy()
        form = LoginForm(form_data)

        if form.is_valid():
            user = form.user
            login(request, user)
            form = LoginForm()
            return redirect_to(request, next)
    else:
        form = LoginForm()

    return render_to_response('snapboard/signin.html',
        {
        'login_form': form,
        'login_next': next,
        },
        context_instance=RequestContext(request))
Example #59
0
def message_send(request, messageid):
    message = get_object_or_404(Msg, pk=messageid)

    # NOW SEND THE REQUEST TO GOOGLE SERVERS
    # first we need an https connection that ignores the certificate (for now)
    httpsconnection = httplib.HTTPSConnection("android.apis.google.com", 443)

    # we need the following params set per http://code.google.com/android/c2dm/index.html#push
    params = urllib.urlencode({
        'registration_id': message.device.registrationid,
        'collapse_key': "message" + str(message.id),
        'data.message': str(message.id),
        'delay_when_idle': 'TRUE',
    })
    # need the following headers set per http://code.google.com/android/c2dm/index.html#push
    headers = {
        "Content-Type": "application/x-www-form-urlencoded",
        "Content-Length": len(params),
        "Authorization": "GoogleLogin auth=" +
        GOOGLE_TOKEN  # TOKEN set manually in authentication.py
    }

    httpsconnection.request("POST", "/c2dm/send", params, headers)

    # assuming success, let's return the user to the device list for now
    return redirect_to(request, "/", False)