def reg(self): title = 'Registration' usertypes = userTypes() states = get_states() msg = '' form = Form(self.request, schema=Registration) if 'form_submitted' in self.request.POST and form.validate(): try: resp = self.request.POST['g-recaptcha-response'] except: self.request.session.flash( 'danger; Failed captcha due to slow network') return HTTPFound(location=self.request.route_url('reg')) recaptcha_r = requests.post( recaptcha_endpoint, dict(secret=buddy_settings('recaptcha_secret'), response=resp)) rdata = recaptcha_r.json() if rdata: if not rdata['success']: msg = 'Failed recaptcha, please solve again' return dict(form=FormRenderer(form), msg=msg, title=title, usertypes=usertypes, states=states) user = form.bind(Users()) if 'ref_email' in self.request.session: referrer = Users.get_by_email( self.request.session['ref_email']) if referrer: user.parent_id = referrer.id with transaction.manager: DBSession.add(user) user.prefix = create_path(user.user_fullname, is_unique) DBSession.flush() timestamp = time.time() + 3600 hmac_key = hmac.new( '%s:%s:%d' % (str(user.id), 'r5$55g35%4#$:l3#24&', timestamp), user.email).hexdigest()[0:10] time_key = base64.urlsafe_b64encode('%d' % timestamp) email_hash = '%s%s' % (hmac_key, time_key) user_regmail(self.request, user.id, user.email, email_hash) headers = buddy_remember(self.request, user, event='R') self.session.flash( "success;You should be receiving an email with a link to activate your " "account within 10 minutes. Doing so will let you post properties/blog on this website." ) return HTTPFound(location=self.request.route_url('account'), headers=headers) return dict(form=FormRenderer(form), title=title, usertypes=usertypes, msg=msg, states=states)
def return_slideshare_upload_form(request): check_login(request) session = request.session redirect_to_google_oauth = False form = Form(request, schema=ImporterChoiceSchema) response = {'form':FormRenderer(form)} username = session['login'].username if form.validate(): original_filename = session['original_filename'] slideshow_id = None if form.data['importer'] == 'slideshare': slideshow_id = upload_to_slideshare("saketkc", original_filename) session['slideshare_id'] = slideshow_id if form.data['importer'] == 'google': if session.has_key('slideshare_oauth'): # RETURNING USER redirect_to_google_oauth = False oauth_token = session['slideshare_oauth']["oauth_token"] oauth_secret = session['slideshare_oauth']["oauth_secret"] guploader = GooglePresentationUploader() guploader.authentincate_client_with_oauth2(oauth_token,oauth_secret) guploader.upload(original_filename) guploader.get_first_revision_feed() guploader.publish_presentation_on_web() resource_id = guploader.get_resource_id().split(':')[1] session['google-resource-id'] = resource_id print "UPLOADING TO GOOGLE" else: print "NEW USER" redirect_to_google_oauth = True session['original-file-path'] = original_filename uploaded_filename = session['uploaded_filename'] if slideshow_id is not None: slideshare_details = get_details(slideshow_id) cnxml = """\ <featured-links> <!-- WARNING! The 'featured-links' section is read only. Do not edit below. Changes to the links section in the source will not be saved. --> <link-group type="supplemental"> <link url="""+ "\"" + uploaded_filename + "\""+""" strength="3">Download the original slides in PPT format</link>""" if slideshow_id is not None: cnxml += """<link url="""+ "\"" + get_slideshow_download_url(slideshare_details) + "\"" +""" strength="2">SlideShare PPT Download Link</link>""" cnxml += """\ </link-group> <!-- WARNING! The 'featured-links' section is read only. Do not edit above. Changes to the links section in the source will not be saved. --> </featured-links>""" session['cnxml'] += cnxml if redirect_to_google_oauth: raise HTTPFound(location=request.route_url('google_oauth')) raise HTTPFound(location=request.route_url('enhance')) return {'form' : FormRenderer(form),'conversion_flag': False, 'oembed': False}
def login_view(request): """ Perform a 'login' by getting the service document from a sword repository. """ templatePath = 'templates/login.pt' config = load_config(request) form = Form(request, schema=LoginSchema) field_list = [ ('username', ), ('password', ), ] session = request.session # validate the form in order to compute all errors valid_form = form.validate() request['errors'] = form.all_errors() # Check for successful form completion if 'form.submitted' in request.POST and valid_form: if form.data['anonymous']: login = AnonymousSession() else: login = auth(form.data['service_document_url'], form.data['username'], form.data['password']) if login is None: request['errors'] = [ "Invalid username or password. Please try again.", ] response = { 'form': FormRenderer(form), 'field_list': field_list, 'config': config, } return render_to_response(templatePath, response, request=request) # The login details are persisted on the session. if TESTING: session['login'] = TestingSession() else: session['login'] = login return HTTPFound(location=request.route_url('choose')) elif 'login' in session: return HTTPFound(location=request.route_url('choose')) # If not signed in, go to login page response = { 'form': FormRenderer(form), 'field_list': field_list, 'config': config, } return render_to_response(templatePath, response, request=request)
def navigate(self, errors=None, form=None): # See if this was a plain navigation attempt view = super(PreviewView, self)._navigate(errors, form, 'workflownav.preview.submitted') if view: return view request = self.request defaults = {} defaults['title'] = request.session.get('title', '') form = Form(request, schema=PreviewSchema, defaults=defaults) return { 'body_base': '%s%s/' % (request.static_url('oerpub.rhaptoslabs.swordpushweb:transforms/'), request.session['upload_dir']), 'body_url': '%s%s/index.html' % (request.static_url('oerpub.rhaptoslabs.swordpushweb:transforms/'), request.session['upload_dir']), 'form': FormRenderer(form), 'editor': EditorHelper(request), 'view': self, }
def view_visit_page(request): visit_type = request.matchdict["form"] health_id = request.matchdict["health_id"] person = None form_type = None health_units = None with transaction.manager: person = models.DBSession.query(models.Person)\ .filter(models.Person.health_id == health_id).first() form_type = models.DBSession.query(models.Form).\ options(joinedload('form_concepts')).get(visit_type) health_units = models.DBSession.query(models.HealthUnit).all() health_units = \ [(health_unit.id, health_unit.name) for health_unit in health_units] visit_form = request.matchdict["form"] form = Form(request, schema="ANCSchema") form_concepts = form_type.form_concepts control_labels = {} if form_concepts: for concept in form_concepts: concept_model = models.DBSession.query(models.Concept).get( concept.concept) control_labels[concept.concept] = concept_model.name return {"page": form_type.name, "person": person, "form": FormRenderer(form), \ "visit_type": visit_type, "form_type": form_type, \ "control_labels": control_labels, "health_units": health_units, "count":0}
def edit(request): settings = load_settings() my = MySetting() for setting in settings: if setting.valuex: my.__dict__[setting.name] = setting.valuex else: my.__dict__[setting.name] = setting.value form = Form(request, schema=SettingSchema, obj=my) if form.validate(): form.bind(my) # persist model somewhere... for setting in settings: if setting.name == "motion_id_prefix": update_setting(setting.name, my.motion_id_prefix) if setting.name == "admin_password": update_setting(setting.name, my.admin_password) if setting.name == "user_password": update_setting(setting.name, my.user_password) if setting.name == "mail_sender": update_setting(setting.name, my.mail_sender) if setting.name == "mail_smtppassword": update_setting(setting.name, my.mail_smtppassword) if setting.name == "mail_template": update_setting(setting.name, "", my.mail_template) return HTTPFound(location=route_path("setting_edit", request)) return dict(renderer=FormRenderer(form))
def view_files(self): self.require_verification() form = Form(self.request, schema=forms.UploadFileSchema) with utils.db_session(self.dbmaker) as session: user = session.query(User).filter(User.username==self.username).first() current_upload_size = sum([f.size for f in user.files]) username = user.username owned_files = dict() shared_files = dict() for f in user.files: shared_with = [k.user.username for k in f.keys] owned_file = dict(shared=shared_with, uploaded_at=f.uploaded_at, size=f.size) owned_files[f.name] = owned_file shared_files[f.name] = dict(size=f.size, owner=f.owner.username) sharable_users = session.query(User).filter(User.sharable==True) sharable_users = sharable_users.filter(User.username!=self.username).all() sharable_users = [u.username for u in sharable_users] return dict( current_upload_size=current_upload_size, form=FormRenderer(form), username=username, uploaded_files=owned_files, sharable_users=sharable_users, shared_files=shared_files )
def user_listing(self): form = Form(self.request) path = self.request.matchdict['prefix'] user = Users.get_by_path(path) page = int(self.request.params.get("page", 1)) page_url = PageURL_WebOb(self.request) active_listings = DBSession.query(Listings).filter(Listings.user == user).filter(Listings.approved==True).\ filter(Listings.declined==False).filter(Listings.status==True).all() past_sales = DBSession.query(Listings).filter( Listings.user == user).filter(Listings.status == False).all() active_paginator = Page(active_listings, page=int(self.request.params.get("page", 1)), items_per_page=10, url=page_url) pastsales_paginator = Page(past_sales, page=int(self.request.params.get("page", 1)), items_per_page=10, url=page_url) title = user.fullname + "'s Listings" return dict(user=user, pastsales_paginator=pastsales_paginator, lis="d", form=FormRenderer(form), active_paginator=active_paginator, title=title)
def view_signup(self): """ Register view for new users that aren't signed up yet """ username = get_param(self.request, 'username') email = get_param(self.request, 'email') password = u'' # Create form by using schemas with validations form = Form(self.request, schema=SignUpSchema, state=State(request=self.request)) if form.validate(): username = self.request.params['username'] password = self.request.params['password'] email = self.request.params['email'] get_resource('users', self.request).add(username, password, email) get_resource('groups', self.request).add(username, group_names['member']) get_resource('groups', self.request).add(username, u'u:%s' % username) self.message = msg['succeed_add_user'] + " " + username _dict = { 'url': self.request.application_url + '/signup', 'username': username, 'email': email, 'password': password, 'form': FormRenderer(form), 'params': self.request.params, 'message': self.message } return dict(self.base_dict.items() + _dict.items())
def login_view(request): main_view = route_url('main', request) came_from = request.params.get('came_from', main_view) user = authenticated_userid(request) form = Form(request, schema=LoginSchema) if request.POST: if 'form.submitted' in request.POST: if form.validate(): username = form.data['username'] passphrase = form.data['passphrase'] if User.check_passphrase(username, passphrase): headers = remember(request, username) request.session.flash(u'Logged in successfully.') return HTTPFound(location=came_from, headers=headers) request.session.flash(u'Failed to login.') #return HTTPFound(location=came_from) return { 'title': not user and 'log in' or 'logged in', 'form': FormRenderer(form), 'loggedin': authenticated_userid(request), '_full': True }
def password_edit_view(request): """ Render the change password form page. Seek the database for the user datas based on user_id used in the route. If the user did not exist then add an error flash message and redirect to the user list. If the user exist then render an empty password form. If the form is validated then change the user password in the database and add success flash message. If the form is not valid, then display again the form with validation errors. :param request: a ``pyramid.request`` object """ _ = request.translate user_id = request.matchdict['user_id'] user = AuthUser.get_by_id(user_id) if not user: request.session.flash(_(u"This user did not exist!"), 'error') return HTTPFound(location=request.route_path('tools.user_list')) form = Form(request, schema=UserPasswordForm, obj=user) if 'form_submitted' in request.params and form.validate(): form.bind(user) DBSession.add(user) request.session.flash(_(u"Password updated."), 'success') return HTTPFound(location=request.route_path('tools.user_list')) return dict(renderer=FormRenderer(form))
def from_area(request): area_id = request.matchdict['area_id'] district = District.get_by_id(area_id) listings=DBSession.query(Listings).filter(Listings.approved==True).\ filter(Listings.declined==False).filter(Listings.district==district).order_by(Listings.modified.desc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(listings, page=page, items_per_page=5, url=page_url) form = Form(request) title = "Properties in %s, %s,%s" % (district.name, district.lga.name, district.lga.state.name) return dict(title=title, paginator=paginator, district=district, form=FormRenderer(form), type='', min_price='', max_price='', state_id=district.lga.state.id, lga_id=district.lga.id, lgas=[(a.id, a.name) for a in district.lga.state.lga.all()], ptype='', beds='', baths='', area_size='', covered_area='', transaction_type='')
def from_category(request): c_id = request.matchdict['category_id'] category = PropertyCategory.get_by_id(c_id) if category.parent: title = "%s in Nigeria" % (category.name) ptype = category.id listings=DBSession.query(Listings).filter(Listings.approved==True).filter(Listings.declined==False).\ filter(Listings.category==category).order_by(Listings.modified.desc()).all() else: ptype = '' title = "%s Properties in Nigeria" % (category.name) category_children = [x.name for x in category.children] listings = DBSession.query(Listings).join(PropertyCategory).filter(Listings.approved==True).\ filter(Listings.declined==False).filter(PropertyCategory.name.in_(category_children)).order_by(Listings.modified.desc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(listings, page=page, items_per_page=10, url=page_url) form = Form(request) return dict(title=title, paginator=paginator, category=category, form=FormRenderer(form), type='', min_price='', max_price='', state_id='', lga_id='', lgas=[], ptype=ptype, beds='', baths='', area_size='', covered_area='', transaction_type='')
def from_state(request): state_name = request.matchdict['state_name'] state = State.get_by_name(state_name) listings=DBSession.query(Listings).filter(Listings.approved==True).\ filter(Listings.declined==False).filter(Listings.state==state).order_by(Listings.modified.desc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(listings, page=page, items_per_page=10, url=page_url) title = "Properties in %s" % (state_name) form = Form(request) return dict(title=title, form=FormRenderer(form), paginator=paginator, state=state, type='', min_price='', max_price='', state_id=state.id, lga_id='', lgas=[(a.id, a.name) for a in state.lga.all()], ptype='', beds='', baths='', area_size='', covered_area='', transaction_type='')
def buy(self): form = Form(self.request) usertypes = userTypes() title = "Properties for sale in Nigeria" listing = DBSession.query(Listings).filter(Listings.listing_type=='For sale').\ filter_by(approved = True).filter(Listings.declined==False).\ filter_by(status=True).order_by(Listings.modified.desc()).all() page = int(self.request.params.get("page", 1)) page_url = PageURL_WebOb(self.request) paginator = Page(listing, page=page, item_count=len(listing), items_per_page=10, url=page_url) return dict(paginator=paginator, title=title, buy='buy', form=FormRenderer(form), usertypes=usertypes, type='Buy', min_price='', max_price='', state_id='', lga_id='', lgas=[], ptype='', beds='', baths='', area_size='', covered_area='', transaction_type='')
def all_listing(self): form = Form(self.request) usertypes = userTypes() title = 'Properties for sale and rent in Nigeria' page = int(self.request.params.get('page', 1)) paginator = Listings.get_paginator(self.request, page) pastsales = DBSession.query(Listings).filter(Listings.approved==True).\ filter(Listings.declined==False).filter(Listings.status==False).all() page_url = PageURL_WebOb(self.request) pastsales_paginator = Page(pastsales, page=int(self.request.params.get("page", 1)), items_per_page=5, url=page_url) self.request.response.cache_control.prevent_auto = True return dict(paginator=paginator, find='all', form=FormRenderer(form), usertypes=usertypes, title=title, pastsales_paginator=pastsales_paginator, type='', min_price='', max_price='', state_id='', lga_id='', lgas=[], ptype='', beds='', baths='', area_size='', covered_area='', transaction_type='')
def motion_add(request): """create a new motion. 1. show new motion form 2. save to database after user submit """ # initialize the form to select all participants all_users = load_users() all_user_options = [(itm.id, itm.name) for itm in all_users] selected_users = [itm.id for itm in all_users] # add four blank options on new motion form form = Form(request, schema=MotionSchema, defaults=dict(participants = selected_users, options=["","","",""])) if form.validate(): title = form.data.get("title") desc = form.data.get("desc") options = form.data.get("options") users = form.data.get("participants") add_motion(title, desc, options, users) return HTTPFound(location=route_path('motion_list', request)) return dict(renderer=FormRenderer(form), all_user_options=all_user_options)
def view_user_edit(self): """ View for editing a single user """ form = Form(self.request, schema=UserEditSchema, state=State(request=self.request)) self.error_message = None if form.validate(): password = self.request.params['password'] if self.context.validate_password(password): if self.request.params['new_password']: password = self.request.params['new_password'] self.message = 'Successfully saved' email = self.request.params['email'] self.context.edit(password, email) else: self.error_message = msg['password_invalid'] _dict = { 'username': self.context.username, 'form': FormRenderer(form), 'email': self.context.email, 'message': self.message, 'error_message': self.error_message } return dict(self.base_dict.items() + _dict.items())
def search(request): """This searches contents i.e Blogs, Questions""" title = "Voices search" search_term = request.params.get('search_term', '') form = Form(request) searchstring = u'%%%s%%' % search_term # generic_filter can be applied to all Node (and subclassed) objects generic_filter = or_( Content.title.like(searchstring), Content.body.like(searchstring), ) results = DBSession.query(Content).filter(Content.type !='listing').filter(generic_filter).\ order_by(Content.title.asc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(results, page=page, items_per_page=10, url=page_url) return render_to_response("buddy:templates/home/searchresult.mako", dict(paginator=paginator, title=title, form=FormRenderer(form)), request=request)
def login(self): if self.logged_in: self.request.session.flash('You are already connected!', queue='notice') return HTTPFound(location=self.request.route_url('home')) self.c.pagename = 'Login' self.c.active_header_nav = 'tools' self.c.active_footer_nav = 'tools-login' params = self.request.params form = Form(self.request, schema=LoginForm, obj=params) if form.validate(): form.bind(params) #clear the cache for user User.by_username(params.get('username'), invalidate=True) user = User.by_username(params.get('username'), cache=None) if user: password = params.get('password') if user.password == User.pass_crypt(password)\ and user.status == 1: user.last_login_date = sa.func.now() self.request.session.flash(u'Welcome back %s !' % user.username, queue='success') headers = security.remember(self.request, user.username) return HTTPFound(location=self.request.route_url('home'), headers=headers) self.request.session.flash(u'Wrong username or password!', queue='notice') return {'item': params, 'form': FormRenderer(form)}
def login_view(request): """ Render the login form. Display an empty login form or check the submited credentials with the ones from the database. Add a success flash message, an userid in the cookies and redirect to the home page if the credentials are goods. Add an error flash message and display again the login form if the credentials are wrong. :param request: a ``pyramid.request`` object """ _ = request.translate form = Form(request, schema=LoginForm) if 'form_submitted' in request.params and form.validate(): username = request.params['username'] password = request.params['password'] if AuthUser.check_password(username, password): auth_user = AuthUser.get_by_username(username) headers = remember(request, auth_user.user_id) request.session.flash(_(u"Successful login."), 'success') return HTTPFound(location=request.route_path('home'), headers=headers) else: request.session.flash(_(u"Check your login credentials!"), 'error') return dict(renderer=FormRenderer(form))
def user_search(request): title = 'Professionals' search_term = request.params.get('search_term', '') form = Form(request) searchstring = u'%%%s%%' % search_term generic_filter = or_(Users.firstname.like(searchstring), Users.surname.like(searchstring), Users.company_name.like(searchstring)) results = DBSession.query(Users).filter(generic_filter).\ filter(and_(Users.email!=u'*****@*****.**',Users.email!=u'*****@*****.**'))\ .order_by((Users.photo!=None).desc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(results, page=page, items_per_page=10, url=page_url) return render_to_response("buddy:templates/search/index.mako", dict(paginator=paginator, title=title, name=search_term, location='', protype='', form=FormRenderer(form)), request=request)
def view_blog_edit(self): form = Form(self.request, schema=BlogCreateSchema, state=State(request=self.request)) blogname = get_param(self.request, 'blogname', self.context.name) text = get_param(self.request, 'text', self.context.description) image_url = get_param(self.request, 'image_url', self.context.image_url) if form.validate(): self.context.name = blogname self.context.description = text self.context.image_url = image_url self.message = msg['saved'] cbs = [p for p in self.request.params.keys() if u'checkbox' in p] # check all the checkbox-parameters and # parse them for cb in cbs: item = self.request.params[cb] self.context.remove(item) self.message = msg['items_removed'] _dict = { 'form': FormRenderer(form), 'message': self.message, 'blogname': blogname, 'text': text, 'image_url': image_url } return dict(self.base_dict.items() + _dict.items())
def change_password(request): """Change user password.""" # Unpack. user = request.user notify = request.registry.notify # Validate the request. form = Form(request, schema=schema.ChangePassword, defaults={'failed': False}) location = get_redirect_location(request) if request.method == 'POST': if form.validate(): d = form.data user = authenticate_user(request, user.username, d['old_password']) if user: # Save new password to the db. user.password = model.encrypt(d['new_password']) model.save(user) # Notify that the password changed. notify(events.UserChangedPassword(request, user)) # Log the user out, so that a change of password will lock out # someone who has compromised the existing password. headers = forget(request) # Notify that the user is logged out. notify(events.UserLoggedOut(request, request.user)) # Redirect. return HTTPFound(location=location, headers=headers) else: form.errors['old_password'] = '******' form.data['next'] = location return {'renderer': FormRenderer(form), 'user': request.user}
def index(self): form = Form(self.request) params = self.request.params protype = params.get('type','') location = params.get('cities_auto','') name = params.get('name','') users = DBSession.query(Users) if protype: users = users.join(User_types).filter(User_types.id==protype) if location and name: st = State.get_by_name(location) name="%"+name+"%" filters = or_(Users.fullname.like(name),Users.company_name.like(name)) users = users.filter(Users.state_id==st.id).filter(filters) if location and not name: st = State.get_by_name(location) users = users.filter(Users.state==st) if name and not location: namelike="%"+name+"%" filters = or_(Users.fullname.like(namelike),Users.company_name.like(namelike)) users = users.filter(filters) users = users.filter(and_(Users.email!=u'*****@*****.**',Users.email!=u'*****@*****.**')).order_by((Users.photo!=None).desc()).all() page_url = PageURL_WebOb(self.request) paginator = Page(users, page=int(self.request.params.get("page", 1)), items_per_page=12, url=page_url) return dict(title="Nairabricks Real Estate Professionals", name = name, location = location, protype= protype, form = FormRenderer(form),paginator=paginator)
def delete_user(request): """Delete user.""" user = request.context if request.method == 'POST': # Redirect. location = get_redirect_location(request) if user is request.user: # User deleted itself, must logout headers = forget(request) request.registry.notify(events.UserLoggedOut( request, request.user)) resp = HTTPFound(location=location, headers=headers) else: resp = HTTPFound(location=location) # Delete user username = user.username model.Session.delete(user) # Fire a ``UserDeleted`` event. request.registry.notify(events.UserDeleted(request, username)) return resp else: form = Form(request, schema=schema.FlexibleSchema) return { 'user': user, 'renderer': FormRenderer(form), }
def settings_view(request): """docstring for settings_view""" master = get_renderer('templates/master.pt').implementation() tracs = None users = None formdata = Formdata() if request.params: tracs = request.params.getall("tracs")[0] users = request.params.getall("users")[0] formdata.tracs = formdata.form_parser(tracs) formdata.users = formdata.form_parser(users) with open("sql/tracs", "w") as file: pickle.dump(formdata.tracs, file) with open("sql/users", "w") as file: pickle.dump(formdata.users, file) with open("sql/tracs") as file: tracs = pickle.load(file) with open("sql/users") as file: users = pickle.load(file) tracs = formdata.create_text(tracs) users = formdata.create_text(users) formdata.tracs = tracs or None formdata.users = users or None form = Form(request) return dict(master=master, renderer=FormRenderer(form), formdata=formdata)
def add(self): form = Form(self.request) p=up(self.request) return dict( title="Add picture to home background", up=p, form = FormRenderer(form))
def user_add(request): form = Form(request, schema=RegistrationSchema) if 'form.submitted' in request.POST and form.validate(): session = DBSession() username = form.data['username'] user = User(username=username, password=form.data['password'], name=form.data['name'], email=form.data['email']) session.add(user) headers = remember(request, username) redirect_url = route_url('main', request) return HTTPFound(location=redirect_url, headers=headers) login_form = login_form_view(request) return { 'form': FormRenderer(form), 'toolbar': toolbar_view(request), 'cloud': cloud_view(request), 'latest': latest_view(request), 'login_form': login_form, }
def userblogfilter(self): path = self.request.matchdict['prefix'] form = Form(self.request) #id = self.request.matchdict['id'] category = self.request.matchdict['category'] user = Users.get_by_path(path) blogs = user.content.filter(Content.type == 'blog').filter( Blogs.categories.any(name=category)).all() bcategor = user.content.filter(Content.type == 'blog').filter( Blogs.user_id == user.id).all() bc = [s.categories for s in bcategor] bc = histogram(bc) title = user.fullname + "'s Blogs on " + category page_url = PageURL_WebOb(self.request) page = int(self.request.params.get('page', 1)) paginator = Page(blogs, page=page, url=page_url) if page > 1: title = title + ' page ' + str(page) return dict(user=user, paginator=paginator, blog_nav_cat=get_navcategories(), form=FormRenderer(form), bl='bl', category=category, title=title, bcategories=bc)