def __call__(self, request, *args, **kwargs): # generate our view via genericbase view = super(GenericForm, self).__call__(request, *args, **kwargs) self.form_class = view.params['form_class'] self.form_args = view.params['form_args'] self.initial = view.params['initial'] self.template_name = view.params['template_name'] self.success_message = view.params['success_message'] if request.method == 'POST': form = self.form_class( data=request.POST, files=request.FILES, **self.form_args ) if form.is_valid(): self.handle_valid(form=form, request=request, *args, **kwargs) if self.success_message: msg = ugettext(self.success_message) messages.success(request, msg, fail_silently=True) redirect = self.redirect(request, *args, **kwargs) if redirect: return redirect else: form = self.form_class(initial=self.initial, **self.form_args) context = RequestContext(request, {}) context.update({ 'form': form, }) context.update(view.params['extra_context']) return render_to_response(self.template_name, context)
def post(request): search_text = request.POST['search_text'] context = RequestContext(request) context.update({ 'posts': Post.objects.search(search_text) }) return render_to_response('search.html', {}, context)
def add_view(self, request): """ new_instance is the created instance of self.model or none, depending on if form.is_valid. Passed, for consistancy's sake to the template as "object" This view is csrf_exempt, which aparently conflicts with django's admin_view wrapper. This is problematic, as it exposes this view to anybody who knows the URL. @@TODO Uploadify doesn't properly pass the csrf_token, hopefully this is fixed in the release version of Uploadify. """ instance_form = self.get_minimal_add_form() form = instance_form(request.POST, request.FILES, prefix=self.base_url()) new_instance = None if form.is_valid(): new_instance = form.save() template = select_template(self.item_add_template) context = RequestContext(request) context.update({ "insert": self, "form": form, "object": new_instance }) response = HttpResponse(template.render(context)) response.status_code = 201 return response response = HttpResponse(form.errors) response.status_code = 400 return response
def login(request): if (request.method == 'GET'): # redirecionamento padrao #carrega o template da tela de login template = loader.get_template('registration/login.html') #carrega o contexto c = RequestContext (request, {}) #retorna o template a ser renderizado return HttpResponse(template.render(c)) if (request.method == 'POST'): #formalidades de seguranca c = {} c.update(csrf(request)) #recebe o form form = LoginForm(request.POST) #redireciona caso esteja autenticado if isUserAutenticated(form) is not None: #redireciona para o template da list return HttpResponseRedirect("/list") else: #redireciona para o template do index return HttpResponseRedirect("/")
def index(request, path=None): f = open("/tmp/log.txt", "a") f.write("path: %s\n" % str(path)) f.write("request: %s\n" % str(request)) path = request.GET.get('page', None) if path == '': path = 'index' f.write("pth: %s \n" % (path)) if path is None: # workaround in history tokens: must have a query return HttpResponseRedirect("./?page=#index") p = Page.objects.get(name=path) f.write("page: %s \n" % (str(p))) f.close() args = {'title': p.name, 'noscript': p.text } context_instance=RequestContext(request) context_instance.autoescape=False try: template = Page.objects.get(name='index.html') except Page.DoesNotExist: template = None if not template: return render_to_response('index.html', args, context_instance) tpl = loader.get_template_from_string(template) context_instance.update(args) tpl = tpl.render(context_instance) return HttpResponse(tpl)
def posting(request): if request.user.is_authenticated(): username = request.user.username useremail = request.user.email messages.get_messages(request) if request.method == 'POST': user = User.objects.get(username=username) diary = models.Diary(user=user) post_form = forms.DiaryForm(request.POST, instance=diary) if post_form.is_valid(): messages.add_message(request, messages.INFO, "日记已保存") post_form.save() return HttpResponseRedirect('/') else: messages.add_message(request, messages.INFO, '要张贴日记,每一个字段都要填...') else: post_form = forms.DiaryForm() messages.add_message(request, messages.INFO, '要张贴日记,每一个字段都要填...') template = get_template('posting.html') request_context = RequestContext(request) request_context.push(locals()) html = template.render(request_context) return HttpResponse(html)
def site_message_form(request): form = f.SiteMessageForm(request.POST or None) if request.method=='POST': if form.is_valid(): form.save() from django.core.mail import send_mail send_mail('[e-pyfan.com]' + form.cleaned_data['subj'], form.cleaned_data['body'], settings.ADMINS[0][1], [settings.ADMINS[0][1]], fail_silently=False) return redirect('/result/message_sent/') base_template = t.Template(m.Template.objects.get(code='BASE_00').body) child_template = t.Template('<P><B>Отправка сообщения:</b></p>{% if form.is_multipart %}' + \ '<form enctype="multipart/form-data" method="post" action="">{% csrf_token %}' + \ '{% else %}' + \ '<form method="post" action="">{% csrf_token %}' + \ '{% endif %}' + \ '<table>' + \ '{{ form.as_table }}' + \ '</table><input type="submit" value="Отправить" />' '</form>') context = {} context.update(csrf(request)) context_instance = RequestContext(request, context) context_instance.update({'form':form}) content = child_template.render(context_instance) menu_items = m.StandardSection.objects.filter(is_menu_item='Y', is_active='Y').order_by('order') base_items = {'menu_items':menu_items, 'content':content, 'STATIC_URL':settings.STATIC_URL, 'curr_date':datetime.datetime.now(tz=pytz.timezone('Europe/Moscow'))} context_instance.update(base_items) return HttpResponse(base_template.render(context_instance))
def detail(request, manifest_name): if request.method == 'POST': if not request.user.has_perm('reports.change_machine'): return HttpResponse(json.dumps('error')) if request.is_ajax(): json_data = json.loads(request.raw_post_data) if json_data: manifest_detail = Manifest.read(manifest_name) for key in json_data.keys(): manifest_detail[key] = json_data[key] Manifest.write(manifest_name, manifest_detail, request.user) return HttpResponse(json.dumps('success')) if request.method == 'GET': manifest = Manifest.read(manifest_name) valid_install_items = Manifest.getValidInstallItems(manifest_name) valid_catalogs = Catalog.list() valid_manifest_names = Manifest.list() manifest_user = manifest.get(MANIFEST_USERNAME_KEY, '') c = RequestContext(request, {'manifest_name': manifest_name.replace(':', '/'), 'manifest_user': manifest_user, 'manifest_user_is_editable': MANIFEST_USERNAME_IS_EDITABLE, 'manifest': manifest, 'valid_install_items': valid_install_items, 'valid_catalogs': valid_catalogs, 'valid_manifest_names': valid_manifest_names, 'user': request.user, 'page': 'manifests'}) c.update(csrf(request)) return render_to_response('manifests/detail.html', c)
def login(request): if request.user.is_authenticated(): return redirect('/') if request.method == 'POST': login_form = forms.LoginForm(request.POST) if login_form.is_valid(): login_name=request.POST['username'].strip() login_password=request.POST['password'] user = authenticate(username=login_name, password=login_password) if user is not None: if user.is_active: auth.login(request, user) messages.add_message(request, messages.SUCCESS, '成功登录了') return redirect('/') else: messages.add_message(request, messages.WARNING, '账号尚未启用') else: messages.add_message(request, messages.WARNING, '登录失败') else: messages.add_message(request, messages.INFO,'请检查输入的字段内容') else: login_form = forms.LoginForm() template = get_template('login.html') request_context = RequestContext(request) request_context.push(locals()) html = template.render(request_context) return HttpResponse(html)
def register(request): if request.method == "POST": form = UserRegistrationForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password'] first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] email = form.cleaned_data['email'] user = User.objects.create_user(username, email, password) user.first_name = first_name user.last_name = last_name user.is_active = False user.save() salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt + user.username).hexdigest() user_profile = UserProfile(user=user, activation_key=activation_key) user_profile.save() base_url = request.get_host() account_activation_link = "%s/user_id=%s&auth_key=%s" % (base_url, username, activation_key) subject = "Welcome to WebSaver! Please activate your account." template_var = { "username": username, "account_activation_link": account_activation_link } send_template_email(subject, "*****@*****.**", [email], "websaver/template/emails/registration_activation_email.html", template_var) return HttpResponseRedirect('/') else: form = UserRegistrationForm(auto_id="%s_id") c = RequestContext(request, { 'form': form, }) c.update(csrf(request)) t = loader.get_template('websaver/template/base.html') return HttpResponse(t.render(c))
def activate(request, userid): if request.method == 'POST': if hashlib.md5(request.POST['pw']).hexdigest() == settings.MASTER_PASSWORD: try: pendinguser = PendingUsers.objects.get(pk=int(userid)) except: return HttpResponseNotFound("No such user", content_type="text/plain") clamuser = CLAMUsers(username=pendinguser.username, password=pendinguser.password,fullname=pendinguser.fullname, institution=pendinguser.institution, mail=pendinguser.mail,active=True) try: clamuser.save() except IntegrityError: return HttpResponseForbidden("User is already activated", content_type="text/plain") send_mail('Webservice account on ' + settings.DOMAIN , 'Dear ' + clamuser.fullname + '\n\nYour webservice account on ' + settings.DOMAIN + ' has been reviewed and activated.\n\n(this is an automated message)', settings.FROMMAIL, [clamuser.mail] + [ x[1] for x in settings.ADMINS ] , fail_silently=False) return HttpResponse("Succesfully activated", content_type="text/plain") else: return HttpResponseForbidden("Invalid password, not activated", content_type="text/plain") else: try: pendinguser = PendingUsers.objects.get(pk=int(userid)) except: return HttpResponseNotFound("No such pending user, has probably already been activated", content_type="text/plain") c = RequestContext(request) c.update(csrf(request)) return render_to_response('activate.html',{'userid': userid},context_instance=c)
def resources(request): context = RequestContext(request) if 'fr' in request.LANGUAGE_CODE.lower(): context.deck_id = 'a351f6b0a3730130c98b12e3c5740641' else: context.deck_id = '1a33a070416b01307b8022000a1de118' return render_to_response('resources.html', context_instance=context)
def about_us(request): context = RequestContext(request) context.a_flatpage = '/about-us/' username = request.user.username if request.user.username else \ 'your-user-name' context.url = request.build_absolute_uri("/%s" % username) return render_to_response('base.html', context_instance=context)
def dashboard(request): context = RequestContext(request) context.form = QuickConverter() content_user = request.user set_profile_data(context, content_user) context.url = request.build_absolute_uri("/%s" % request.user.username) return render_to_response("dashboard.html", context_instance=context)
def tutorial(request): context = RequestContext(request) context.template = 'tutorial.html' username = request.user.username if request.user.username else \ 'your-user-name' context.url = request.build_absolute_uri("/%s" % username) return render_to_response('base.html', context_instance=context)
def kml_export(request, username, id_string): # read the locations from the database context = RequestContext(request) context.message = "HELLO!!" owner = get_object_or_404(User, username=username) xform = get_object_or_404(XForm, id_string=id_string, user=owner) helper_auth_helper(request) if not has_permission(xform, owner, request): return HttpResponseForbidden(_(u'Not shared.')) context.data = kml_export_data(id_string, user=owner) response = \ render_to_response("survey.kml", context_instance=context, mimetype="application/vnd.google-earth.kml+xml") response['Content-Disposition'] = \ disposition_ext_and_date(id_string, 'kml') audit = { "xform": xform.id_string, "export_type": Export.KML_EXPORT } audit_log( Actions.EXPORT_CREATED, request.user, owner, _("Created KML export on '%(id_string)s'.") % { 'id_string': xform.id_string, }, audit, request) # log download as well audit_log( Actions.EXPORT_DOWNLOADED, request.user, owner, _("Downloaded KML export on '%(id_string)s'.") % { 'id_string': xform.id_string, }, audit, request) return response
def profile_settings(request, username): context = RequestContext(request) content_user = check_and_set_user(request, username) context.content_user = content_user profile, created = UserProfile.objects.get_or_create(user=content_user) if request.method == 'POST': form = UserProfileForm(request.POST, instance=profile) if form.is_valid(): # get user # user.email = cleaned_email form.instance.user.email = form.cleaned_data['email'] form.instance.user.save() form.save() # todo: add string rep. of settings to see what changed audit = {} audit_log( Actions.PROFILE_SETTINGS_UPDATED, request.user, content_user, _("Profile settings updated."), audit, request) return HttpResponseRedirect(reverse( public_profile, kwargs={'username': request.user.username} )) else: form = UserProfileForm( instance=profile, initial={"email": content_user.email}) return render_to_response("settings.html", {'form': form}, context_instance=context)
def access_denied(request): context = RequestContext(request) context.user_manager_email = "*****@*****.**" return render_to_response( "access_denied.html", context_instance=context )
def render_to_response(self, context, **response_kwargs): response = self.response_class(filename=self.zip_filename, **response_kwargs) objects = context.get('object_list', []) if not objects and 'object' in context and context['object']: objects = [context['object']] # Create a single object context to render for obj in objects: obj_context = RequestContext(self.request, context) obj_context.update({ 'object': obj, 'object_list': None, obj._meta.model_name: obj, self.get_context_object_name(objects): None}) filename = self.object_filename % obj.pk rendered = render_to_string( template_name=self.object_template_name, context_instance=obj_context, dirs=self.object_template_dirs, ) response.append(filename, rendered) response.close() return response
def Page6(request): if CheckAccess(request,'8') != 'OK': return render_to_response("auto/notaccess/page6.html") if request.method == 'POST': form = AddDriverForm(request.POST) if form.is_valid(): location = form.cleaned_data['location'] driver = form.cleaned_data['driver'] license = form.cleaned_data['license'] category = form.cleaned_data['category'] (driver_kod,driver_name) = driver.split('#') AddADriver(GetUserKod(request),driver_kod,location,driver_name,license,category) else: form = AddDriverForm() if request.method == 'GET': try: delete_id = request.GET['delete_id'] DelADriver(delete_id) except: pass data = GetDriverList() c = RequestContext(request,{'form':form,'data':data}) c.update(csrf(request)) return render_to_response("auto/page6.html",c)
def get(self, request): request_args = dict(getattr(settings, 'BROWSERID_REQUEST_ARGS', {})) # Only pass an email to the JavaScript if the current user was # authed with our auth backend. backend_name = self.request.session.get(auth.BACKEND_SESSION_KEY) backend = auth.load_backend(backend_name) if backend_name else None if isinstance(backend, BrowserIDBackend): email = getattr(request.user, 'email', '') else: email = '' # Different CSRF libraries (namely session_csrf) store the CSRF # token in different places. The only way to retrieve the token # that works with both the built-in CSRF and session_csrf is to # pull it from the template context processors via # RequestContext. context = RequestContext(request) csrf_token = context.get('csrf_token', None) return JSONResponse({ 'userEmail': email, 'loginUrl': reverse('browserid.login'), 'logoutUrl': reverse('browserid.logout'), 'requestArgs': request_args, 'csrfToken': csrf_token, })
def country_details(request): context = RequestContext(request) countries = CountryDetails.objects \ .values('country__name', 'country__id') \ .distinct() context.update({'countries': countries}) return render_to_response("country_details.html", context)
def report_internal_faculty_cv(request): class InternalFacultyCVForm(forms.Form): if request.user.is_superuser: instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all()) else: instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user)) c = RequestContext(request) c.update(csrf(request)) # if 'course_name' in request.GET and request.GET['course_name']: if request.method == 'POST': # form submitted form = InternalFacultyCVForm(request.POST) form.is_valid() instructor = form.cleaned_data['instructor'] instructor = instructor[0] inner_response = report_internal_faculty_cv_pdf(request, instructor) http_response = HttpResponse(inner_response, c) escaped_name = str(instructor.name).replace(' ', '_') this_year = datetime.datetime.now().strftime("%Y") filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf" http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"' return http_response else: # form not yet submitted ... display it form = InternalFacultyCVForm() return render_to_response('internal_faculty_cv.html' , { 'form': form }, c)
def json_render(request, template=None, context=None, status='success', redirect_fallback=None): if not request.is_ajax() and redirect_fallback is not None: return redirect(redirect_fallback) result = context or {} if template is not None: request_context = RequestContext(request) # `context` not specified in RequestContext constructor since otherwise # the returned instance may have overriden keys, since the template # context processors take precedence over `context`. So, we have to # update after instantiation. request_context.update(context or {}) result = { 'html': render_to_string(template, request_context), } result.update({ 'status': status, '__messages__': [{ 'level': x.tags.split(' ')[0], 'message': x.message, } for x in get_messages(request)], }) return result
def __init__(self, request, section): RequestContext.__init__(self, request) if sitenav.has_key(section): navsection = sitenav[section] else: navsection = {} self.update({'navmenu': navsection})
def friend_invite(request): if request.method == 'POST': form = FriendInviteForm(request.POST) if form.is_valid(): invitation = Invitation( name = form.clean_data['name'], email = form.clean_data['email'], code = User.objects.make_random_password(20), sender = request.user ) invitation.save() try: invitation.send() messages.add_message(request,SUCCESS,'你已经邀请%s为你的好友!一封邀请信已经发送到他的邮箱!' % form.clean_data['email'].encode('utf-8')) except: messages.add_message(request,ERROR,'向地址%s发送邀请信的过程发生错误,发送失败!将跳转到发送页面再次发送!' % form.clean_data['email'].encode('utf-8')) return HttpResponseRedirect(request.get_full_path()+'?raw=1') else: form = FriendInviteForm() context = RequestContext(request,{'form':form}) template = 'friend_invite.html' if request.method == 'GET' and request.GET.has_key('raw'): raw=request.GET['raw'] context.update({'raw':raw}) template = 'friend_invite_form.html' return render_to_response(template,context_instance = context)
def blacklist_words(request): form = BlackListWordsForm(request.user) try: fb_user = FacebookUser.objects.get(user=request.user) except FacebookUser.DoesNotExist: # TODO Proper 404 HttpResponse("Not Found") if request.method == 'GET': initial = BlackListedWords.objects.filter(user=fb_user) initial_words = [] if initial: initial_words = [i.word for i in initial] request_context = RequestContext(request) request_context.push({ 'form': form, 'user': request.user, 'initial_words': initial_words }) return render_to_response('blacklist_words.html', request_context) else: form = BlackListWordsForm(request.user, data=request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(reverse('blacklist_words')) else: return HttpResponse(form.errors)
def get_html(self, request=None): # контекст данной странички #context = t.Context({'content':self.html}) #содержимое данной странички content = self.html #контекст базового шаблона menu_items = StandardSection.objects.filter(is_menu_item='Y', is_active='Y').order_by('order') base_items = {'menu_items':menu_items, 'content':t.Template(self.template.body).render(t.Context({'content':self.html})), 'STATIC_URL':settings.STATIC_URL} context_instance = None if request: context = {} context.update(csrf(request)) context_instance = RequestContext(request, context) context_instance.update(base_items) else: # если тек страница имеет контекст, то добавляем его в base_context типа: base_items.update(content_items) # контекст базового шаблона, включающий всё base_context = t.Context(base_items) if self.template.base: if context_instance: return t.Template(self.template.base.body).render(context_instance) else: return t.Template(self.template.base.body).render(base_context) return content
def index(request): t = loader.get_template('mobile/index.html') c = RequestContext(request) posts = Post.objects.all() c.update({'posts':posts}) return HttpResponse(t.render(c))
def alerts(request): print 'inside alerts view method' context = RequestContext(request) device_list_side_nav = get_device_list_side_navigation() context.update(device_list_side_nav) if request.user.get_profile().group.name.lower() == 'admin': usr = UserFullName.objects.filter(username=request.user)[0] _registered_alerts = [ob.as_json() for ob in ActiveAlert.objects.all()] _alerts = [ob.as_json() for ob in EventTrigger.objects.all()] _alert_pr = [ob.as_json() for ob in Priority.objects.all()] _n_type = [ob.as_json() for ob in NotificationChannel.objects.all()] active_al = get_notifications() bemoss_not = general_notifications() _temp_range = [ob.as_json() for ob in TempRangeValue.objects.all()] _temp_failure_time = [ob.as_json() for ob in TempFailureTime.objects.all()] context.update({'b_al': bemoss_not}) return render_to_response( 'admin/alarms.html', {'registered_alerts': _registered_alerts, 'alerts': _alerts, 'priority': _alert_pr, 'n_type': _n_type, 'user_full_name': usr, 'temp_range': _temp_range, 'temp_failure_time': _temp_failure_time, 'active_al': active_al}, context) else: return HttpResponseRedirect('/home/')
def meta(self): return render_to_string(self.meta_template, self._build_context(), context_instance=RequestContext(self.request))
def view_empleado_kardex(request): empleados = Empleados.objects.all() return render_to_response('personal/view_empleado_kardex.html', { 'empleados': empleados, }, context_instance=RequestContext(request))
def privado(request): usuario = request.user return render_to_response('user/privado.html', {'usuario': usuario}, context_instance=RequestContext(request))
def home(request): return render_to_response('index_personal.html', context_instance=RequestContext(request))
def new_asistencia(request): if request.method == 'POST': formulario = AsistenciaForm(request.POST, request.FILES) if formulario.is_valid(): carnet = formulario.cleaned_data['ci'] emple = Empleados.objects.get(ci=carnet) hoy = datetime.datetime.now() if Empleados.objects.filter( ci=carnet) and contratacion.objects.filter( fecha_entrada__lte=hoy, fecha_salida__gte=hoy, estado='ACTIVO', empleado__ci__exact=carnet): cod_emple = emple.id if Asistencia.objects.filter(empleado_id=cod_emple, fecha=hoy): q1 = Asistencia.objects.get(fecha=hoy, empleado_id=cod_emple) else: Asistencia.objects.create( fecha=hoy, empleado_id=cod_emple, ) q1 = Asistencia.objects.get(fecha=hoy, empleado_id=cod_emple) hora = hoy.strftime("%H:%M") #Modificar las Horas if hora >= "06:00" and hora <= "08:15": #Entrada mañana if not Asistencia.objects.filter(empleado_id=emple.id, fecha=hoy, entrada_m__lte="08:15", entrada_m__gte="06:00"): q1.entrada_m = hora q1.save() elif hora >= "13:00" and hora <= "14:15": #"Entrada Tarde" if not Asistencia.objects.filter(empleado_id=emple.id, fecha=hoy, entrada_t__lte="14:15", entrada_t__gte="13:00"): q1.entrada_t = hora q1.save() elif hora >= "12:00" and hora <= "12:59": #salida mañana if not Asistencia.objects.filter(empleado_id=emple.id, fecha=hoy, salida_m__lte="12:59", salida_m__gte="12:00"): q1.salida_m = hora q1.save() elif hora >= "18:00" and hora <= "22:00": #salida tarde if not Asistencia.objects.filter(empleado_id=emple.id, fecha=hoy, salida_t__lte="22:00", salida_t__gte="18:00"): q1.salida_t = hora q1.save() else: if hora >= "08:16" and hora <= "11:59": #entrada mañana tarde if not Asistencia.objects.filter( empleado_id=emple.id, fecha=hoy, entrada_m__lte="11:59", entrada_m__gte="08:16"): q1.entrada_m = hora q1.obs_m = 'RETRASO' q1.save() if hora >= "14:16" and hora <= "17:59": #Entrada tarde retraso if not Asistencia.objects.filter( empleado_id=emple.id, fecha=hoy, entrada_t__lte="17:59", entrada_t__gte="14:16"): q1.entrada_t = hora q1.obs_t = 'RETRASO' q1.save() if hora >= "22:01" and hora <= "05:59": return HttpResponseRedirect('/personal/') else: return HttpResponseRedirect('/view/kardex/' + str(emple.id) + '/') return HttpResponseRedirect('/view/kardex/' + str(emple.id) + '/') else: formulario = AsistenciaForm() return render_to_response('personal/new_asistencia.html', {'formulario': formulario}, context_instance=RequestContext(request))
def control(request): context = RequestContext(request) return render_to_response('command/control.html', {'username': request.session['username']}, context)
def render_content(self, extra_context=None): context = self._build_context() if extra_context is not None: context.update(extra_context) return render_to_string(self.content_template, context, context_instance=RequestContext(self.request))
def signup(request): template = loader.get_template('social/signup.html') context = RequestContext(request, { 'appname': appname, }) return HttpResponse(template.render(context))
def index(request): return render_to_response("index.html", context_instance=RequestContext(request))
def no_taxes(request, template_name="manage/product_taxes/no_taxes.html"): """Displays that there are no taxes. """ return render_to_response(template_name, RequestContext(request, {}))
def post(self, request, *args, **kwargs): skey = kwargs.get('sk', None) if not skey: # something went wrong or someone is playing around, skey must be here, but its not return self._redirect_on_stale() # we are paginating remember = cache.get(skey) if not remember: # cache has expired return self._redirect_on_stale() try: # verify cache content post_data = remember[0] form_data = remember[1] except: return self._redirect_on_stale() # renew the cache cache.delete(skey) skey = get_unique_random(20) cache.set(skey, remember, 24*60*60) # build query based on form input query, job_info = get_jobpost_query(request, form_data) elist_key = get_cache_key_from_post(post_data) jobpost_list = cache.get(elist_key) if jobpost_list: created = get_or_create_cache_access_key('Job_Search_View') if created: cache.delete(elist_key) jobpost_list = None if not jobpost_list: # search jobpost_list = get_jobpost_list(query) cache.set(elist_key, jobpost_list, 8*60) # remember for x min. if not jobpost_list: jobpost_list = [] spage = kwargs.get('sp', 1) paginate = Paginator(jobpost_list, 5) try: jobposts = paginate.page(spage) except PageNotAnInteger: # If page is not an integer, deliver first page. jobposts = paginate.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. jobposts = paginate.page(paginate.num_pages) form = SearchJobForm(request, post_data) search_keywords = post_data.get('keywords', '') # if user has specific search specific_search = False if job_info or search_keywords: specific_search = True c = RequestContext(request, { 'form': form, 'jobposts': jobposts, 'job_info': job_info, 'search_key': skey, 'search_kw': search_keywords, 'specific_search': specific_search, 'total_result': len(jobpost_list) }) return self.render_to_response(c)
def update(request): """Update contact info""" init_data = {} shop = Config.objects.get_current() try: contact = Contact.objects.from_request(request, create=False) except Contact.DoesNotExist: contact = None if request.method == "POST": new_data = request.POST.copy() form = ExtendedContactInfoForm(data=new_data, shop=shop, contact=contact, shippable=True, initial=init_data) if form.is_valid(): if contact is None and request.user: contact = Contact(user=request.user) custID = form.save(contact=contact) request.session[CUSTOMER_ID] = custID redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '') if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = urlresolvers.reverse('satchmo_account_info') return http.HttpResponseRedirect(redirect_to) else: signals.satchmo_contact_view.send(contact, contact=contact, contact_dict=init_data) else: if contact: #If a person has their contact info, make sure we populate it in the form for item in contact.__dict__.keys(): init_data[item] = getattr(contact, item) if contact.shipping_address: for item in contact.shipping_address.__dict__.keys(): init_data["ship_" + item] = getattr( contact.shipping_address, item) if contact.billing_address: for item in contact.billing_address.__dict__.keys(): init_data[item] = getattr(contact.billing_address, item) if contact.primary_phone: init_data['phone'] = contact.primary_phone.phone if contact.organization: init_data['organization'] = contact.organization.name signals.satchmo_contact_view.send(contact, contact=contact, contact_dict=init_data) form = ExtendedContactInfoForm(shop=shop, contact=contact, shippable=True, initial=init_data) init_data['form'] = form if shop.in_country_only: init_data['country'] = shop.sales_country else: countries = shop.countries() if countries and countries.count() == 1: init_data['country'] = countries[0] init_data['next'] = request.REQUEST.get(REDIRECT_FIELD_NAME, '') context = RequestContext(request, init_data) return render_to_response('contact/update_form.html', context_instance=context)
def email_raw_add(request): """ Upload an email using Raw. Should be an AJAX POST. :param request: Django request object (Required) :type request: :class:`django.http.HttpRequest` :returns: :class:`django.http.HttpResponse` """ fields_form = EmailRawUploadForm(request.user, request.POST) json_reply = { 'form': fields_form.as_table(), 'success': False, 'message': "" } if request.method != "POST": message = "Must submit via POST" if request.is_ajax(): json_reply['message'] = message return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': message}, RequestContext(request)) if not fields_form.is_valid(): message = "Form is invalid." if request.is_ajax(): json_reply['message'] = message return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': message}, RequestContext(request)) method = "Raw Upload" if fields_form.cleaned_data['source_method']: method = method + " - " + fields_form.cleaned_data['source_method'] obj = handle_pasted_eml( fields_form.cleaned_data['raw_email'], fields_form.cleaned_data['source'], fields_form.cleaned_data['source_reference'], request.user.username, method, campaign=fields_form.cleaned_data['campaign'], confidence=fields_form.cleaned_data['campaign_confidence'], bucket_list=fields_form.cleaned_data['bucket_list'], ticket=fields_form.cleaned_data['ticket']) if not obj['status']: if request.is_ajax(): json_reply['message'] = obj['reason'] return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': obj['reason']}, RequestContext(request)) if request.is_ajax(): json_reply['success'] = True del json_reply['form'] json_reply[ 'message'] = 'Email uploaded successfully. <a href="%s">View email.</a>' % reverse( 'crits.emails.views.email_detail', args=[obj['object'].id]) return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return HttpResponseRedirect( reverse('crits.emails.views.email_detail', args=[obj['object'].id]))
def index(request): c=RequestContext(request,{}) return render_to_response('portal/index.html', c)
def logs(request): context = RequestContext(request) context['errors'] = logger.get_cached_logs() return render_to_response('kegadmin/logs.html', context)
def upload_attach(request, email_id): """ Upload an attachment for an email. :param request: Django request object (Required) :type request: :class:`django.http.HttpRequest` :param email_id: The ObjectId of the email to upload attachment for. :type email_id: str :returns: :class:`django.http.HttpResponse` """ if request.method == 'POST': form = UploadFileForm(request.user, request.POST, request.FILES) if form.is_valid(): cleaned_data = form.cleaned_data analyst = request.user.username users_sources = user_sources(analyst) method = cleaned_data['method'] or "Add to Email" bucket_list = cleaned_data.get( form_consts.Common.BUCKET_LIST_VARIABLE_NAME) ticket = cleaned_data.get(form_consts.Common.TICKET_VARIABLE_NAME) email_addr = None if request.POST.get('email'): email_addr = request.user.email email = Email.objects(id=email_id, source__name__in=users_sources).first() if not email: return render_to_response( 'file_upload_response.html', { 'response': json.dumps({ 'success': False, 'message': "Could not find email." }) }, RequestContext(request)) result = create_email_attachment( email, cleaned_data, analyst, cleaned_data['source'], method, cleaned_data['reference'], cleaned_data['campaign'], cleaned_data['confidence'], bucket_list, ticket, request.FILES.get('filedata', None), request.POST.get('filename', None), request.POST.get('md5', None), email_addr, cleaned_data['inherit_sources']) # If successful, tell the browser to redirect back to this email. if result['success']: result['redirect_url'] = reverse( 'crits.emails.views.email_detail', args=[email_id]) return render_to_response('file_upload_response.html', {'response': json.dumps(result)}, RequestContext(request)) else: form.fields['related_md5'].widget = forms.HiddenInput( ) #hide field so it doesn't reappear return render_to_response( 'file_upload_response.html', { 'response': json.dumps({ 'success': False, 'form': form.as_table() }) }, RequestContext(request)) else: return HttpResponseRedirect( reverse('crits.emails.views.email_detail', args=[email_id]))
def create_tap(request): context = RequestContext(request) form = forms.ChangeKegForm()
def email_yaml_add(request, email_id=None): """ Upload an email using YAML. Should be an AJAX POST. :param request: Django request object (Required) :type request: :class:`django.http.HttpRequest` :param email_id: The ObjectId of an existing email to update. :type email_id: str :returns: :class:`django.http.HttpResponse` """ yaml_form = EmailYAMLForm(request.user, request.POST) json_reply = { 'form': yaml_form.as_table(), 'success': False, 'message': "" } if request.method != "POST": message = "Must submit via POST" if request.is_ajax(): json_reply['message'] = message return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': message}, RequestContext(request)) if not yaml_form.is_valid(): message = "Form is invalid." if request.is_ajax(): json_reply['message'] = message return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': message}, RequestContext(request)) method = "YAML Upload" if yaml_form.cleaned_data['source_method']: method = method + " - " + yaml_form.cleaned_data['source_method'] obj = handle_yaml( yaml_form.cleaned_data['yaml_data'], yaml_form.cleaned_data['source'], yaml_form.cleaned_data['source_reference'], request.user.username, method, email_id=email_id, save_unsupported=yaml_form.cleaned_data['save_unsupported'], campaign=yaml_form.cleaned_data['campaign'], confidence=yaml_form.cleaned_data['campaign_confidence'], bucket_list=yaml_form.cleaned_data['bucket_list'], ticket=yaml_form.cleaned_data['ticket']) if not obj['status']: if request.is_ajax(): json_reply['message'] = obj['reason'] return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return render_to_response('error.html', {'error': obj['reason']}, RequestContext(request)) if request.is_ajax(): json_reply['success'] = True json_reply[ 'message'] = 'Email uploaded successfully. <a href="%s">View email.</a>' % reverse( 'crits.emails.views.email_detail', args=[obj['object'].id]) return HttpResponse(json.dumps(json_reply), content_type="application/json") else: return HttpResponseRedirect( reverse('crits.emails.views.email_detail', args=[obj['object'].id]))
def transaction_list(request): if request.method == "POST": item_name = request.session.get('curr_item') license_id = request.session.get('curr_license') obj3 = Accounts.objects.filter(user=request.user)[0] context = {"acct": obj3.account_no, "status": 1, "item1": item_name, "license1": license_id} # , "price":price} # context = {"acct":obj3.account_no, "status":1, "item1":"clothing", "license1":2828} print("proceeding for transaction") return render_to_response('customer_bank/redirect_bis.html',context, context_instance=RequestContext(request)) else: # return render(request, 'customer_bank/transaction.html', {}) # time=datetime._format_time() obj4 = Accounts.objects.filter(user=request.user)[0] return render_to_response('customer_bank/transaction.html',locals(), context_instance=RequestContext(request))
def backup_restore(request): context = RequestContext(request) return render_to_response('kegadmin/backup-restore.html', context)
def render_template(self, tpl, context): template = loader.get_template(tpl) return template.render(RequestContext(self.strategy.request, context))
def login_bank_list(request): account = request.POST.get('acct') price = request.POST.get('price') item = request.POST.get('item') license = request.POST.get('license') m = request.POST.get('m') company_name = '' # hashing recieved data #hashing #account2=int(account) # account1 = account.encode('utf-8') # salt = "a0b0c0d0" # salt1 = salt.encode('utf-8') # n=(hashlib.sha512(salt1+account1).hexdigest())#.encode('utf-8') # print(n) # print(m) # m1 = m.encode('utf-8') # print(m1) #hashing # # n = hashlib.sha512(account1 + salt1).hexdigest() # hashlib # obj=Signup.objects.filter(user=request.user)[0] # obj.license_id password = '' # if (m1 != n): # return redirect('/bank/corrupt/', {}) if request.POST: # print("inside post") request.session['curr_license'] = license request.session['curr_item'] = item account_no = request.POST.get('account_no') password = request.POST.get('password') # print(company_name + password) # accountint=int(account) # if (m != n): # return redirect('/bank/corrupt/', {}) user = authenticate(username=request.POST.get('account_no'), password=password) if user is not None: # if user.is_active: login(request, user) print("You're successfully logged in!") obj1 = Accounts.objects.filter(account_no=account_no)[0] # =license_id1)[0] bal = obj1.balance if (bal >= int(price)): bal = bal - int(price) # obj = Accounts(user=user, # account_no = account_no, # balance=bal # #account_date = request.POST.get('account_date'), # ) # obj.save() obj1.balance = bal obj1.save() obj3 = Accounts.objects.filter(account_no=9999)[0] # adding money to merchants account merchant_bal = obj3.balance merchant_bal = merchant_bal + int(price) obj3.balance = merchant_bal obj3.save() # obj2 = Accounts(user=user, # account_no = 9999, # balance=merchant_bal # #account_date = request.POST.get('account_date'), # ) # obj2.save() # return render(request,'customer_bank/transaction.html',locals(),context_instance=RequestContext(request)) return redirect('/bank/transaction/', {}) else: return redirect('/bank/transaction_fail/', {}) # else: # state = "Your account is not active, please contact the site admin." else: state = " Your company_name and/or password were incorrect." return render(request, 'customer_bank/login_bank.html', locals(), context_instance=RequestContext(request))
def object_detail(request, year, month, day, queryset, date_field, month_format='%b', day_format='%d', object_id=None, slug=None, slug_field='slug', template_name=None, template_name_field=None, template_loader=loader, extra_context=None, context_processors=None, template_object_name='object', mimetype=None, allow_future=False): """ Generic detail view from year/month/day/slug or year/month/day/id structure. Templates: ``<app_label>/<model_name>_detail.html`` Context: object: the object to be detailed """ if extra_context is None: extra_context = {} try: tt = time.strptime('%s-%s-%s' % (year, month, day), '%s-%s-%s' % ('%Y', month_format, day_format)) date = datetime.date(*tt[:3]) except ValueError: raise Http404 model = queryset.model now = datetime.datetime.now() if isinstance(model._meta.get_field(date_field), DateTimeField): lookup_kwargs = { '%s__range' % date_field: (datetime.datetime.combine(date, datetime.time.min), datetime.datetime.combine(date, datetime.time.max)) } else: lookup_kwargs = {date_field: date} # Only bother to check current date if the date isn't in the past and future objects aren't requested. if date >= now.date() and not allow_future: lookup_kwargs['%s__lte' % date_field] = now if object_id: lookup_kwargs['%s__exact' % model._meta.pk.name] = object_id elif slug and slug_field: lookup_kwargs['%s__exact' % slug_field] = slug else: raise AttributeError, "Generic detail view must be called with either an object_id or a slug/slugfield" try: obj = queryset.get(**lookup_kwargs) except ObjectDoesNotExist: raise Http404, "No %s found for" % model._meta.verbose_name if not template_name: template_name = "%s/%s_detail.html" % (model._meta.app_label, model._meta.object_name.lower()) if template_name_field: template_name_list = [getattr(obj, template_name_field), template_name] t = template_loader.select_template(template_name_list) else: t = template_loader.get_template(template_name) c = RequestContext(request, { template_object_name: obj, }, context_processors) for key, value in extra_context.items(): if callable(value): c[key] = value() else: c[key] = value response = HttpResponse(t.render(c), mimetype=mimetype) populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.name)) return response
def render_string(self, html, context): template = loader.get_template_from_string(html) return template.render(RequestContext(self.strategy.request, context))
def archive_week(request, year, week, queryset, date_field, template_name=None, template_loader=loader, extra_context=None, allow_empty=True, context_processors=None, template_object_name='object', mimetype=None, allow_future=False): """ Generic weekly archive view. Templates: ``<app_label>/<model_name>_archive_week.html`` Context: week: (date) this week object_list: list of objects published in the given week """ if extra_context is None: extra_context = {} try: tt = time.strptime(year + '-0-' + week, '%Y-%w-%U') date = datetime.date(*tt[:3]) except ValueError: raise Http404 model = queryset.model now = datetime.datetime.now() # Calculate first and last day of week, for use in a date-range lookup. first_day = date last_day = date + datetime.timedelta(days=7) lookup_kwargs = { '%s__gte' % date_field: first_day, '%s__lt' % date_field: last_day, } # Only bother to check current date if the week isn't in the past and future objects aren't requested. if last_day >= now.date() and not allow_future: lookup_kwargs['%s__lte' % date_field] = now object_list = queryset.filter(**lookup_kwargs) if not object_list and not allow_empty: raise Http404 if not template_name: template_name = "%s/%s_archive_week.html" % ( model._meta.app_label, model._meta.object_name.lower()) t = template_loader.get_template(template_name) c = RequestContext(request, { '%s_list' % template_object_name: object_list, 'week': date, }) for key, value in extra_context.items(): if callable(value): c[key] = value() else: c[key] = value return HttpResponse(t.render(c), mimetype=mimetype)
def new_context(parent_context): """ Create new context rather than modifying parent context """ if 'request' in parent_context: return RequestContext(parent_context['request']) else: return Context()
def registration(req, pk=None): contact = None sellerSummary = None if pk is not None: contact = get_object_or_404(Contact, pk=pk) if req.method == "POST": if req.POST["submit"] == "Delete Contact": contact.delete() return HttpResponseRedirect(reverse(registration)) elif "bulk" in req.FILES: # TODO use csv module #reader = csv.reader(open(req.FILES["bulk"].read(), "rb")) #for row in reader: for line in req.FILES["bulk"]: line_list = line.split(',') name = line_list[0].strip() backend_name = line_list[1].strip() identity = line_list[2].strip() contact = Contact(name=name) contact.save() # TODO deal with errors! backend = Backend.objects.get(name=backend_name) connection = Connection(backend=backend, identity=identity,\ contact=contact) connection.save() return HttpResponseRedirect(reverse(registration)) else: contact_form = ContactForm(instance=contact, data=req.POST) if contact_form.is_valid(): contact = contact_form.save() return HttpResponseRedirect(reverse(registration)) else: contact_form = ContactForm(instance=contact) #Not allowing user to add contacts through the UI for now #If we eventually do, the line below sets the new contacts' #organization to that of the logged in user ################# #instance=Contact(organization=req.user.get_profile().organization)) seller_summary = getSellerSummary(contact) bulk_form = BulkRegistrationForm() if req.user.is_staff: ctable = ContactTable(Contact.objects.exclude(alias='nobody'), request=req) org = None else: ctable = ContactTable(Contact.objects.filter( organization=req.user.get_profile().organization), request=req) org = req.user.get_profile().organization return render_to_response("registration/dashboard.html", { "organization": org, "contacts_table": ctable, "contact_form": contact_form, "bulk_form": bulk_form, "contact": contact, "seller_summary": seller_summary }, context_instance=RequestContext(req))
def archive_day(request, year, month, day, queryset, date_field, month_format='%b', day_format='%d', template_name=None, template_loader=loader, extra_context=None, allow_empty=False, context_processors=None, template_object_name='object', mimetype=None, allow_future=False): """ Generic daily archive view. Templates: ``<app_label>/<model_name>_archive_day.html`` Context: object_list: list of objects published that day day: (datetime) the day previous_day (datetime) the previous day next_day (datetime) the next day, or None if the current day is today """ if extra_context is None: extra_context = {} try: tt = time.strptime('%s-%s-%s' % (year, month, day), '%s-%s-%s' % ('%Y', month_format, day_format)) date = datetime.date(*tt[:3]) except ValueError: raise Http404 model = queryset.model now = datetime.datetime.now() if isinstance(model._meta.get_field(date_field), DateTimeField): lookup_kwargs = { '%s__range' % date_field: (datetime.datetime.combine(date, datetime.time.min), datetime.datetime.combine(date, datetime.time.max)) } else: lookup_kwargs = {date_field: date} # Only bother to check current date if the date isn't in the past and future objects aren't requested. if date >= now.date() and not allow_future: lookup_kwargs['%s__lte' % date_field] = now object_list = queryset.filter(**lookup_kwargs) if not allow_empty and not object_list: raise Http404 # Calculate the next day, if applicable. if allow_future: next_day = date + datetime.timedelta(days=1) elif date < datetime.date.today(): next_day = date + datetime.timedelta(days=1) else: next_day = None if not template_name: template_name = "%s/%s_archive_day.html" % ( model._meta.app_label, model._meta.object_name.lower()) t = template_loader.get_template(template_name) c = RequestContext( request, { '%s_list' % template_object_name: object_list, 'day': date, 'previous_day': date - datetime.timedelta(days=1), 'next_day': next_day, }, context_processors) for key, value in extra_context.items(): if callable(value): c[key] = value() else: c[key] = value return HttpResponse(t.render(c), mimetype=mimetype)
def splash(request): data = {} # load summary stats with open("%s/model/model_output/summary_stats.csv" % (BASE_DIR), 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=',') for index, row in enumerate(reader): if index == 0: columns = row else: values = row for i in range(len(columns)): data[columns[i]] = values[i] data['ttm_return'] = float(data['ttm_return']) * 100 data['latest_date'] = parser.parse(data['latest_date']) data['updated_date'] = parser.parse(data['updated_date']) # load stock pics data for i in ('short', 'long'): picks = [] with open("%s/model/model_output/%s_picks.csv" % (BASE_DIR, i), 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=',') for index, row in enumerate(reader): if index > 0: try: # change returns to percentage row[1] = float(row[1]) * 100 row[5] = float(row[5]) * 100 # interpret pairs as list row[4] = ast.literal_eval(row[4]) picks.append(row[1:]) except: pass data["%s_picks" % (i)] = picks # load test results values = [] with open("%s/model/model_output/test_results.csv" % (BASE_DIR), 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=',') for index, row in enumerate(reader): if index == 0: columns = row else: values.append([ row[0], float(row[columns.index(str( data['return_period_days_fwd']))]) ]) # load index returns index_returns = {} with open("%s/model/model_output/index_returns.csv" % (BASE_DIR), 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=',') for index, row in enumerate(reader): try: index_returns[row[0]] = float( row[1] ) # float(row[columns.index(str(data['return_period_days']))]) except: pass # merge returns and convert date format for i in values: if i[0] in index_returns: i.append(index_returns[i[0]]) i[0] = time.mktime(parser.parse(i[0]).timetuple()) * 1000 # shift returns to future period shifted_values = [] for t, i in enumerate(values): if t == 0: start_date = i[0] if t > 0: shifted_values.append( [values[t][0], values[t - 1][1], values[t - 1][2]]) values = shifted_values data['returns'] = {} data['returns']['strategy'] = [] data['returns']['index'] = [] for t, i in enumerate(values): data['returns']['index'].append([i[0], (i[2] - 1) * 100]) data['returns']['strategy'].append([i[0], (i[1] - 1) * 100]) data['returns_prod'] = {} data['returns_prod']['strategy'] = [[start_date, 0.]] data['returns_prod']['index'] = [[start_date, 0.]] for t, i in enumerate(values): data['returns_prod']['index'].append( [i[0], (data['returns_prod']['index'][-1][1] + 1) * i[2] - 1]) data['returns_prod']['strategy'].append( [i[0], (data['returns_prod']['strategy'][-1][1] + 1) * i[1] - 1]) for i in ('strategy', 'index'): for k in range(len(data['returns_prod'][i])): data['returns_prod'][i][k][ 1] = data['returns_prod'][i][k][1] * 100. #return HttpResponse(data['returns_prod']['index']) return render_to_response('splash.html', data, context_instance=RequestContext(request))
def archive_month(request, year, month, queryset, date_field, month_format='%b', template_name=None, template_loader=loader, extra_context=None, allow_empty=False, context_processors=None, template_object_name='object', mimetype=None, allow_future=False): """ Generic monthly archive view. Templates: ``<app_label>/<model_name>_archive_month.html`` Context: month: (date) this month next_month: (date) the first day of the next month, or None if the next month is in the future previous_month: (date) the first day of the previous month object_list: list of objects published in the given month """ if extra_context is None: extra_context = {} try: tt = time.strptime("%s-%s" % (year, month), '%s-%s' % ('%Y', month_format)) date = datetime.date(*tt[:3]) except ValueError: raise Http404 model = queryset.model now = datetime.datetime.now() # Calculate first and last day of month, for use in a date-range lookup. first_day = date.replace(day=1) if first_day.month == 12: last_day = first_day.replace(year=first_day.year + 1, month=1) else: last_day = first_day.replace(month=first_day.month + 1) lookup_kwargs = { '%s__gte' % date_field: first_day, '%s__lt' % date_field: last_day, } # Only bother to check current date if the month isn't in the past and future objects are requested. if last_day >= now.date() and not allow_future: lookup_kwargs['%s__lte' % date_field] = now object_list = queryset.filter(**lookup_kwargs) if not object_list and not allow_empty: raise Http404 # Calculate the next month, if applicable. if allow_future: next_month = last_day elif last_day <= datetime.date.today(): next_month = last_day else: next_month = None # Calculate the previous month if first_day.month == 1: previous_month = first_day.replace(year=first_day.year - 1, month=12) else: previous_month = first_day.replace(month=first_day.month - 1) if not template_name: template_name = "%s/%s_archive_month.html" % ( model._meta.app_label, model._meta.object_name.lower()) t = template_loader.get_template(template_name) c = RequestContext( request, { '%s_list' % template_object_name: object_list, 'month': date, 'next_month': next_month, 'previous_month': previous_month, }, context_processors) for key, value in extra_context.items(): if callable(value): c[key] = value() else: c[key] = value return HttpResponse(t.render(c), mimetype=mimetype)