def concept_save_view(request):
if "concept" in request.POST:
form = Form(request, schema=ConceptAnswersSchema())
if form.validate():
answers = []
concept_answers = form.bind(models.ConceptAnswer())
concept = concept_answers.concept
concept_answers = concept_answers.concept_answer
for concept_answer in concept_answers:
answer = models.ConceptAnswer()
answer.concept = concept
answer.concept_answer = concept_answer
answers.append(answer)
with transaction.manager:
models.DBSession.add_all(answers)
else:
print form.all_errors()
print "NOT VALIDATED"
return "I saw it"
form = Form(request, schema=ConceptSchema())
concept_model = None
if form.validate():
concept = form.bind(models.Concept())
#with transaction.manager:
# models.DBSession.add(concept)
concept_model = models.DBSession.merge(concept)
models.DBSession.flush()
return HTTPFound(request.route_url("concept_edit_page", page="Concepts",\
concept_id=concept_model.id))
else:
print "Failed"
def login_form(request, defaults):
"""Chooses the right login form based on the
configuration and calls it.
"""
settings = request.registry.settings
if settings and asbool(settings.get('simpleauth.allow_email_login',
False)):
return Form(request, schema=schema.LoginAllowEmail, defaults=defaults)
else:
return Form(request, schema=schema.Login, defaults=defaults)
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 register(self):
form = Form(self.request, schema=forms.RegistrationSchema) # Me add
if 'form.submitted' in self.request.POST and form.validate():
username = form.data['username']
user = User(username=username,
password=form.data['password'],
name=form.data['name'],
email=form.data['email'],
created_at=time.time())
with utils.db_session(self.dbmaker) as session:
userExist = session.query(User).filter(
User.username == username).first()
if not userExist:
session.add(user)
headers = remember(self.request, username)
return HTTPFound(
location=self.request.route_url('send_verify'),
headers=headers)
else:
self.request.session.flash(
u'This User is exist, please create another "Username" or "Email" !!!'
)
return HTTPFound(
location=self.request.route_url('register'))
return dict(username=self.username)
def __call__(self):
if self.user.permissions & Permission.NEWS != Permission.NEWS:
raise HTTPForbidden(
'You are not authorized to create news articles.')
self.breadcrumbs.add('News', self.request.route_url('news'))
self.breadcrumbs.add('Create', self.request.route_url('news_create'))
self.title = 'Create News Article'
form = Form(self.request,
schema=NewsSchema,
defaults={
'title': u'',
'content': u''
})
if 'submit' in self.request.POST and form.validate():
token = self.request.POST.get('_csrf')
if token is None or token != self.request.session.get_csrf_token():
raise HTTPForbidden('CSRF token is invalid or missing.')
article = News(title=self._validated(NewsSchema, form, 'title'),
content=self._validated(NewsSchema, form,
'content'),
submitTime=datetime.datetime.utcnow(),
lastModified=datetime.datetime.utcnow(),
ownerid=self.user.id,
isDeleted=False)
self.dbsession.add(article)
self.dbsession.flush()
return HTTPFound(location=self.request.route_url(
'news_article', articleid=article.id))
return self.finalize({'form': form})
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_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 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 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 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 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 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_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_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 test_initialize_with_obj(self):
from pyramid_simpleform import Form
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, obj=SimpleObj(name='test'))
self.assert_(form.data['name'] == 'test')
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 test_initialize_with_defaults(self):
from pyramid_simpleform import Form
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={'name': 'test'})
self.assert_(form.data['name'] == 'test')
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 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 add(self):
form = Form(self.request)
p=up(self.request)
return dict(
title="Add picture to home background",
up=p,
form = FormRenderer(form))
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 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)
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 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 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 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_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 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 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 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='')
