python类RequestContext()的实例源码

def wizard(request):
    form = FilterWizard([FilterWiZardForm1, FilterWiZardForm2, FilterWiZardForm3])
    if request.method == 'GET':
        print('CHECK HERE')
        query_string = request.META['QUERY_STRING']
        if query_string != '':
            print("LIMPANDO")
            new_query_string = []
            query_string = query_string.split('&')
            for item in query_string:
                if not (item.startswith('csrfmiddlewaretoken') or item.startswith('hash') or item.startswith('wizard')):
                    #get here only the ones need to be cleaned Ex. 1-chr
                    item = "-".join(item.split('-', 2)[1:])
                    new_query_string.append(item)

            #create new query
            filterstring = "&".join(new_query_string)
            # return HttpResponseRedirect('/filter_analysis/?%s' % (filterstring))
            return redirect(reverse('filter_analysis')+'?'+filterstring)





    return form(context=RequestContext(request), request=request)

def wizard(request):
    form = FilterWizard([FilterWiZardForm1, FilterWiZardForm2, FilterWiZardForm3])
    if request.method == 'GET':
        print('CHECK HERE')
        query_string = request.META['QUERY_STRING']
        if query_string != '':
            print("LIMPANDO")
            new_query_string = []
            query_string = query_string.split('&')
            for item in query_string:
                if not (item.startswith('csrfmiddlewaretoken') or item.startswith('hash') or item.startswith('wizard')):
                    #get here only the ones need to be cleaned Ex. 1-chr
                    item = "-".join(item.split('-', 2)[1:])
                    new_query_string.append(item)

            #create new query
            filterstring = "&".join(new_query_string)
            # return HttpResponseRedirect('/filter_analysis/?%s' % (filterstring))
            return redirect(reverse('filter_analysis')+'?'+filterstring)





    return form(context=RequestContext(request), request=request)

def index(request):
    if request.method == 'POST':
        form = PathAnalysisForm(request.POST)
        if  form.is_valid():
            query = form.cleaned_data['search']
            print(query)
            #here is where the magic happens!
            #search in kegg
#            data = kegg_rest_request('list/pathway/hsa')
#            pathways = kegg_rest_request('find/pathway/%s' % (query))
            pathways = Pathway.objects.filter(Q(name__icontains=query))
            # print pathways

    else:
        form = PathAnalysisForm()
#        pathways = kegg_rest_request('list/pathway/hsa')
        pathways = Pathway.objects.all()    


    return render_to_response('pathway_analysis/index.html', {'form': form, 'pathways': pathways}, context_instance=RequestContext(request))

def render_table_actions(self):
        """Renders the actions specified in ``Meta.table_actions``."""
        template_path = self._meta.table_actions_template
        table_actions_template = template.loader.get_template(template_path)
        bound_actions = self.get_table_actions()
        extra_context = {"table_actions": bound_actions,
                         "table_actions_buttons": [],
                         "table_actions_menu": []}
        if self._meta.filter and (
                self._filter_action(self._meta._filter_action, self.request)):
            extra_context["filter"] = self._meta._filter_action
        for action in bound_actions:
            if action.__class__ in self._meta.table_actions_menu:
                extra_context['table_actions_menu'].append(action)
            elif action != extra_context.get('filter'):
                extra_context['table_actions_buttons'].append(action)
        context = template.RequestContext(self.request, extra_context)
        self.set_multiselect_column_visibility(len(bound_actions) > 0)
        return table_actions_template.render(context)

def render_row_actions(self, datum, pull_right=True, row=False):
        """Renders the actions specified in ``Meta.row_actions`` using the
        current row data. If `row` is True, the actions are rendered in a row
        of buttons. Otherwise they are rendered in a dropdown box.
        """
        if row:
            template_path = self._meta.row_actions_row_template
        else:
            template_path = self._meta.row_actions_dropdown_template

        row_actions_template = template.loader.get_template(template_path)
        bound_actions = self.get_row_actions(datum)
        extra_context = {"row_actions": bound_actions,
                         "row_id": self.get_object_id(datum),
                         "pull_right": pull_right}
        context = template.RequestContext(self.request, extra_context)
        return row_actions_template.render(context)

def __init__(self, request, template, context, content_type, **kwargs):
        super(BaseCsvResponse, self).__init__()
        self['Content-Disposition'] = 'attachment; filename="%s"' % (
            kwargs.get("filename", "export.csv"),)
        self['Content-Type'] = content_type
        self.context = context
        self.header = None
        if template:
            # Display some header info if provided as a template
            header_template = django_template.loader.get_template(template)
            context = django_template.RequestContext(request, self.context)
            self.header = header_template.render(context)

        if self.header:
            self.out.write(self.encode(self.header))

        self.write_csv_header()

        for row in self.get_row_data():
            self.write_csv_row(row)

        self.out.flush()
        self.content = self.out.getvalue()
        self.out.close()

def __init__(self, request, template, context, content_type, **kwargs):
        super(BaseCsvStreamingResponse, self).__init__()
        self['Content-Disposition'] = 'attachment; filename="%s"' % (
            kwargs.get("filename", "export.csv"),)
        self['Content-Type'] = content_type
        self.context = context
        self.header = None
        if template:
            # Display some header info if provided as a template
            header_template = django_template.loader.get_template(template)
            context = django_template.RequestContext(request, self.context)
            self.header = header_template.render(context)

        self._closable_objects.append(self.out)

        self.streaming_content = self.get_content()

def get_index(request):
    # response = requests.get('http://127.0.0.1:8000/api/chairmans/')
    # chairmans = response.json()

    if 'type' in request.GET:
        type = request.GET['type']
        chairmans = Chairman.objects.filter(type=type).order('-num')
    else:
        chairmans = Chairman.objects.all().order('-num')

    # chairmans_set = SortedSet('chairmans_set')
    # chairmans_hash = SortedSet('chairmans_hash')
    # chairmans = map(_convert_chairman, chairmans_set.revmembers)
    # chairmans = map(_convert_chairman, chairmans_hash.members)

    return render_to_response('index.html', locals(),
                              context_instance=RequestContext(request))

def fetch(request):
    fetcher = Fetcher()
    fetcher.fetch_cc()
    fetcher.fetch_douyu()
    fetcher.fetch_longzhu()
    fetcher.fetch_quanmin()
    fetcher.fetch_xiongmao()
    fetcher.fetch_zhanqi()
    fetcher.fetch_huya()

    # chairmans_set = SortedSet('chairmans_set')
    # charimans_hash = Hash('chairmans_hash')
    for chairman in fetcher.chairmans:
        try:
            if chairman.is_valid():
                # charimans_hash[chairman.id] = chairman
                # chairmans_set.add(chairman, chairman.num)
                chairman.save()
            else:
                print chairman.errors
        except Exception, e:
            print e

    return render_to_response('index.html', locals(),
                              context_instance=RequestContext(request))

def rate_limit_tasks(self, request, queryset):
        tasks = set([task.name for task in queryset])
        opts = self.model._meta
        app_label = opts.app_label
        if request.POST.get('post'):
            rate = request.POST['rate_limit']
            with current_app.default_connection() as connection:
                for task_name in tasks:
                    rate_limit(task_name, rate, connection=connection)
            return None

        context = {
            'title': _('Rate limit selection'),
            'queryset': queryset,
            'object_name': force_text(opts.verbose_name),
            'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
            'opts': opts,
            'app_label': app_label,
        }

        return render_to_response(
            self.rate_limit_confirmation_template, context,
            context_instance=RequestContext(request),
        )

def test_preferences_cp(self):
        request = RequestFactory().get('/')
        context = context_processors.preferences_cp(request)

        # context should have preferences.
        my_preferences = context['preferences']

        # preferences should have test MyPreferences object member.
        my_preferences = my_preferences.MyPreferences
        self.failUnless(isinstance(my_preferences, MyPreferences),
                        "%s should be instance of MyPreferences." % my_preferences)

        # With preferences_cp is loaded as a TEMPLATE_CONTEXT_PROCESSORS
        # templates should have access to preferences object.
        context_instance = RequestContext(request)
        t = Template("{% if preferences %}{{ preferences }}{% endif %}")
        self.failUnless(t.render(context_instance), "preferences should be \
available in template context.")

        t = Template("{% if preferences.MyPreferences %}{{ \
preferences.MyPreferences }}{% endif %}")
        self.failUnless(t.render(context_instance), "MyPreferences should be \
available as part of preferences var in template context.")

def addVmServer(request):
    if request.method == "GET":
        return render_to_response('vmServer/add_server.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"??????","url":'#'},{"name":"????","url":"/addServer"}]},
                                  context_instance=RequestContext(request))

    elif  request.method == "POST":
        try:     
            VmServer.objects.create(hostname=request.POST.get('hostname'),
                                    username=request.POST.get('username',None),
                                    vm_type=request.POST.get('vm_type'),
                                    server_ip=request.POST.get('server_ip'),
                                    passwd=request.POST.get('passwd',None),
                                    status=0,)
            return render_to_response('vmServer/add_server.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"??????","url":'#'},{"name":"????","url":"/addServer"}]},
                                  context_instance=RequestContext(request))
        except Exception,e:
            return render_to_response('vmServer/add_server.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"??????","url":'#'},{"name":"????","url":"/addServer"}],
                                   "errorInfo":e},
                                  context_instance=RequestContext(request))

def login(request):
    if request.session.get('username') is not None:
        return HttpResponseRedirect('/profile',{"user":request.user})
    else:
        username = request.POST.get('username')
        password = request.POST.get('password') 
        user = auth.authenticate(username=username,password=password)
        if user and user.is_active:
            auth.login(request,user)
            request.session['username'] = username
            return HttpResponseRedirect('/profile',{"user":request.user})
        else:
            if request.method == "POST":
                return render_to_response('login.html',{"login_error_info":"???????????????"},
                                                        context_instance=RequestContext(request))  
            else:
                return render_to_response('login.html',context_instance=RequestContext(request))

def listStorage(request,id):        
    if request.method == "GET":
        try:
            vServer = VmServer.objects.get(id=id)
        except Exception,e:
            return render_to_response('404.html',context_instance=RequestContext(request))
        try:
            VMS = LibvirtManage(vServer.server_ip,vServer.username, vServer.passwd, vServer.vm_type)
            SERVER = VMS.genre(model='server')
            if SERVER:
                storageList = SERVER.getVmStorageInfo()
                VMS.close()
            else:return render_to_response('404.html',context_instance=RequestContext(request))
        except Exception,e:
            return render_to_response('404.html',context_instance=RequestContext(request))        
        return render_to_response('vmStorage/list_storage.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"?????","url":'#'},
                                                                    {"name":"?????","url":"/listStorage/%d/" % vServer.id}],
                                    "vmServer":vServer,"storageList":storageList}, context_instance=RequestContext(request))

def viewStorage(request,id,name): 
    if request.method == "GET":
        try:
            vServer = VmServer.objects.get(id=id)
        except:
            return render_to_response('404.html',context_instance=RequestContext(request))        
        try:
            VMS = LibvirtManage(vServer.server_ip,vServer.username, vServer.passwd, vServer.vm_type)
            STORAGE = VMS.genre(model='storage')
            if STORAGE:
                storage = STORAGE.getStorageInfo(name)
                VMS.close()
            else:return render_to_response('404.html',context_instance=RequestContext(request))
        except Exception,e:
            return render_to_response('404.html',context_instance=RequestContext(request))    
        return render_to_response('vmStorage/view_storage.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"?????","url":'#'},
                                                                    {"name":"?????","url":"/listStorage/%d/" % vServer.id},
                                                                    {"name":"?????","url":"/viewStorage/%d/%s/" % (vServer.id,name)}],
                                    "vmServer":vServer,"storage":storage}, context_instance=RequestContext(request))

def tempInstance(request): 
    if request.method == "GET":  
        tempList = VmInstance_Template.objects.all()
        return render_to_response('vmInstance/temp_instance.html',
                                  {"user":request.user,"localtion":[{"name":"??","url":'/'},{"name":"????","url":'/tempInstance'}],
                                   "tempList":tempList},
                                  context_instance=RequestContext(request)) 
    elif request.method == "POST":
        op = request.POST.get('op')
        if op in ['add','modf','del'] and request.user.has_perm('VManagePlatform.add_vminstance_template'):
            if op == 'add':
                result = VmInstance_Template.objects.create(name=request.POST.get('name'),cpu=request.POST.get('cpu'),
                                                       mem=request.POST.get('mem'),disk=request.POST.get('disk'))
                if isinstance(result, str):return JsonResponse({"code":500,"data":result,"msg":"?????"})                   
                else:return JsonResponse({"code":200,"data":None,"msg":"?????"})
        else:return JsonResponse({"code":500,"data":None,"msg":"????????????????????"})

def project_edit(request, project_id):

    proj = Project.objects.get(pk=project_id)

    if request.method == 'POST':

        title = request.POST.get('title', False)
        text = request.POST.get('text', False)
        project_priority = int(request.POST.get('project_priority', False))
        project_duedate = datetime.datetime.fromtimestamp(
            int(request.POST.get('project_duedate', False)))

        proj.title = title
        proj.text = text
        proj.priority = project_priority
        proj.due_date = project_duedate
        proj.save()

        return redirect('/taskManager/' + project_id + '/')
    else:
        return render_to_response(
            'taskManager/project_edit.html', {'proj': proj}, RequestContext(request))

# A4: Insecure Direct Object Reference (IDOR)

def note_create(request, project_id, task_id):
    if request.method == 'POST':

        parent_task = Task.objects.get(pk=task_id)

        note_title = request.POST.get('note_title', False)
        text = request.POST.get('text', False)

        note = Notes(
            title=note_title,
            text=text,
            user=request.user,
            task=parent_task)

        note.save()
        return redirect('/taskManager/' + project_id + '/' +
                        task_id, {'new_note_added': True})
    else:
        return render_to_response(
            'taskManager/note_create.html', {'task_id': task_id}, RequestContext(request))

# A4: Insecure Direct Object Reference (IDOR)

def register_page(request):
    if request.method == 'POST':
        form = RegistrationForm(request.POST)
        if form.is_valid():
            user = User.objects.create_user(
                username=form.cleaned_data['username'],
                password=form.cleaned_data['password1'],
                email=form.cleaned_data['email']
            )
            return HttpResponseRedirect('/')
    else:
        form = RegistrationForm()
    variables = RequestContext(request, {
        'form': form
    })
    return render_to_response(
        'registration/register.html', variables
    )

def work_timer(
        request,
        process_id,
        commitment_id=None):
    process = get_object_or_404(Process, id=process_id)
    agent = get_agent(request)
    ct = None
    if commitment_id:
        ct = get_object_or_404(Commitment, id=commitment_id)
        #if not request.user.is_superuser:
        #    if agent != ct.from_agent:
        #        return render_to_response('valueaccounting/no_permission.html')
    template_params = create_worktimer_context(
        request,
        process,
        agent,
        ct,
    )
    return render_to_response("work/work_timer.html",
        template_params,
        context_instance=RequestContext(request))

def locations(request):
    agent = get_agent(request)
    locations = Location.objects.all()
    nolocs = Location.objects.filter(latitude=0.0)
    latitude = settings.MAP_LATITUDE
    longitude = settings.MAP_LONGITUDE
    zoom = settings.MAP_ZOOM
    return render_to_response("valueaccounting/locations.html", {
        "agent": agent,
        "locations": locations,
        "nolocs": nolocs,
        "latitude": latitude,
        "longitude": longitude,
        "zoom": zoom,
        "help": get_help("locations"),
    }, context_instance=RequestContext(request))

def radial_graph(request, agent_id):
    agent = get_object_or_404(EconomicAgent, id=agent_id)
    agents = agent.with_all_associations()
    connections = {}
    for agnt in agents:
        if agnt not in connections:
            connections[agnt] = 0
        cxs = [assn.is_associate for assn in agnt.all_has_associates()]
        for cx in cxs:
            if cx not in connections:
                connections[cx] = 0
            connections[cx] += 1

    return render_to_response("valueaccounting/radial_graph.html", {
        "agents": agents,
        "root": agent,
    }, context_instance=RequestContext(request))

def test_patterns(request):
    pattern_form = PatternSelectionForm(data=request.POST or None)
    pattern = None
    slots = []
    if request.method == "POST":
        if pattern_form.is_valid():
            pattern = pattern_form.cleaned_data["pattern"]
            slots = pattern.event_types()
            #import pdb; pdb.set_trace()
            for slot in slots:
                slot.resource_types = pattern.get_resource_types(slot)
                slot.facets = pattern.facets_for_event_type(slot)

    return render_to_response("valueaccounting/test_patterns.html", {
        "pattern_form": pattern_form,
        "pattern": pattern,
        "slots": slots,
    }, context_instance=RequestContext(request))

def exchange_types(request):
    #import pdb; pdb.set_trace()
    if request.method == "POST":
        new_form = NewExchangeTypeForm(data=request.POST)
        if new_form.is_valid():
            ext = new_form.save(commit=False)
            ext.created_by = request.user
            ext.save()

    supply_exchange_types = ExchangeType.objects.supply_exchange_types()
    demand_exchange_types = ExchangeType.objects.demand_exchange_types()
    internal_exchange_types = ExchangeType.objects.internal_exchange_types()
    new_form = NewExchangeTypeForm()

    return render_to_response("valueaccounting/exchange_types.html", {
        "supply_exchange_types": supply_exchange_types,
        "demand_exchange_types": demand_exchange_types,
        "internal_exchange_types": internal_exchange_types,
        "new_form": new_form,
    }, context_instance=RequestContext(request))

def project_wip(request, project_id):
    #import pdb; pdb.set_trace()
    project = get_object_or_404(EconomicAgent, pk=project_id)
    process_list = project.wip()
    paginator = Paginator(process_list, 25)

    page = request.GET.get('page')
    try:
        processes = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        processes = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        processes = paginator.page(paginator.num_pages)

    return render_to_response("valueaccounting/project_wip.html", {
        "project": project,
        "processes": processes,
    }, context_instance=RequestContext(request))

def finished_processes(request, agent_id):
    #import pdb; pdb.set_trace()
    project = get_object_or_404(EconomicAgent, pk=agent_id)
    process_list = project.finished_processes()
    paginator = Paginator(process_list, 25)

    page = request.GET.get('page')
    try:
        processes = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        processes = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        processes = paginator.page(paginator.num_pages)

    return render_to_response("valueaccounting/finished_processes.html", {
        "project": project,
        "processes": processes,
    }, context_instance=RequestContext(request))

def edit_extended_bill(request, resource_type_id):

    #start_time = time.time()
    rt = get_object_or_404(EconomicResourceType, pk=resource_type_id)
    output_ctype, inheritance = rt.main_producing_process_type_relationship()
    #import pdb; pdb.set_trace()
    nodes = rt.generate_xbill()
    resource_type_form = EconomicResourceTypeChangeForm(instance=rt)
    feature_form = FeatureForm()
    names = EconomicResourceType.objects.values_list('name', flat=True)
    resource_names = '~'.join(names)
    #end_time = time.time()
    #print("edit_extended_bill view elapsed time was %g seconds" % (end_time - start_time))
    return render_to_response("valueaccounting/edit_xbill.html", {
        "resource_type": rt,
        "output_ctype": output_ctype,
        "nodes": nodes,
        "photo_size": (128, 128),
        "big_photo_size": (200, 200),
        "resource_type_form": resource_type_form,
        "feature_form": feature_form,
        "resource_names": resource_names,
        "help": get_help("ed_asmbly_recipe"),
    }, context_instance=RequestContext(request))

def delete_process_type_confirmation(request, 
        process_type_id, resource_type_id):
    pt = get_object_or_404(ProcessType, pk=process_type_id)
    side_effects = False
    next = request.POST.get("next")
    if next == None:
        next = '/%s/%s/' % ('accounting/edit-xbomfg', resource_type_id)
    if pt.resource_types.all():
        side_effects = True
        return render_to_response('valueaccounting/process_type_delete_confirmation.html', {
            "process_type": pt,
            "resource_type_id": resource_type_id,
            "side_effects": side_effects,
            "next": next,
            }, context_instance=RequestContext(request))
    else:
        pt.delete()
        return HttpResponseRedirect(next)

def order_timeline(request, order_id):
    order = get_object_or_404(Order, pk=order_id)
    first_process = order.first_process_in_order()
    timeline_date = datetime.date.today().strftime("%b %e %Y 00:00:00 GMT-0600")
    if first_process:
        if first_process.start_date:
            timeline_date = first_process.start_date.strftime("%b %e %Y 00:00:00 GMT-0600")
    unassigned = Commitment.objects.unfinished().filter(
        independent_demand=order,
        from_agent=None,
        event_type__relationship="work").order_by("due_date")
    return render_to_response("valueaccounting/timeline.html", {
        "orderId": order.id,
        "context_id": 0,
        "useContextId": 0,
        "timeline_date": timeline_date,
        "unassigned": unassigned,
    }, context_instance=RequestContext(request))

def misc(request):
    if not request.user.is_superuser:
        return render_to_response('valueaccounting/no_permission.html') 

    context_agent = None
    context_agents = EconomicAgent.objects.context_agents()
    if context_agents:
        context_agent = context_agents[0]
        for ca in context_agents:
            if ca.events.all().count() > context_agent.events.all().count():
                context_agent = ca

    ca_form = ContextAgentSelectionForm()
    if request.method == "POST":
        form = ContextAgentSelectionForm(data=request.POST)
        if form.is_valid():
            data = form.cleaned_data
            agent = data["selected_agent"]
            return HttpResponseRedirect('/%s/%s/'
                % ('accounting/create-distribution', agent.id))    

    return render_to_response("valueaccounting/misc.html", {
        "context_agent": context_agent,
        "ca_form": ca_form,
    }, context_instance=RequestContext(request))