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 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 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 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 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 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 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 zone_view(self):
zonename = self.request.matchdict['zonename']
page = int(self.request.params['page']
) if 'page' in self.request.params else 0
search = self.request.params[
'search'] if 'search' in self.request.params else None
zonefile = settings.zones[zonename]
zone = Zone(zonename, zonefile)
if search:
records = zone.get_records(name=search)
else:
records = zone.get_records()
entries = []
for record in records:
protected = name_is_protected(zonename, record.name)
entries.append({'record': record, 'protected': protected})
page_url = PageURL_WebOb(self.request)
entries = Page(entries, page, url=page_url)
return {
"zonename": zonename,
"entries": entries,
"serial": zone.serial,
}
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 list_view(request):
query_args = {}
if "filter" in request.params:
keys = list(index(request.params["filter"]))
query_args.update({"search_terms": {"$in": keys}})
if "keyword" in request.params:
query_args.update({"keywords": {"$in": [request.params["keyword"]]}})
docs = request.db.docs.find(spec=query_args)
docs.sort("created", DESCENDING)
item_count = docs.count()
page = int(request.params.get("page", 1))
items_per_page = 10
url_maker = PageURL_WebOb(request)
docs = Page(
list(docs[(page - 1) * items_per_page:page * items_per_page]),
url=url_maker,
page=page,
items_per_page=items_per_page,
item_count=item_count,
presliced_list=True,
)
distinct_keywords = request.db.docs.distinct("keywords")
distinct_keywords.sort()
return {"docs": docs, "distinct_keywords": distinct_keywords}
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 get_explore_ourpicks(cls, request, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
now = int(round(time.time() / 60 / 60)) + 1
gravity = 1.8
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin\
(Qvote, and_(Question.questionasker==Qvote.questionasker,\
Qvote.userid == logged_in_alias)).filter(Question.askedby !="Sebastian").filter(Question.askedby !="sebastian").filter(Question.answered==True).order_by(func.random()).offset(20).limit(20), page,
url=page_url, items_per_page=20)
def get_paginator(cls, request, page=1):
page_url = PageURL_WebOb(request)
search = cls.listing_bunch(cls.modified.desc())
return Page(search,
page,
url=page_url,
items_per_page=10,
item_count=len(search))
def get_explore_trending100(cls, request, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
now = int(round(time.time() / 60 / 60)) + 1
gravity = 1.8
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin\
(Qvote, and_(Question.questionasker==Qvote.questionasker,\
Qvote.userid == logged_in_alias)).filter(Question.askedby !="Sebastian").filter(Question.askedby !="sebastian").filter(Question.answered==True).order_by(sa.desc((Question.qkarma -1) /\
func.pow((now - Question.unixage), gravity))).limit(100), page,
url=page_url, items_per_page=100)
def get_hot(cls, request, channellower, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
now = int(round(time.time() / 60 / 60)) + 1
gravity = 1.8
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin\
(Qvote, and_(Question.questionasker==Qvote.questionasker,\
Qvote.userid == logged_in_alias)).filter(Question.askedtoalias == channellower).order_by(sa.desc((Question.qkarma -1) /\
func.pow((now - Question.unixage), gravity))), page,
url=page_url, items_per_page=20)
def home(request):
check_task_expiration()
# no user in the DB yet
if DBSession.query(User.username).count() == 0: # pragma: no cover
request.override_renderer = 'start.mako'
return dict(page_id="start")
query = DBSession.query(Project)
user_id = authenticated_userid(request)
user = None
if user_id is not None:
user = DBSession.query(User).get(user_id)
if not user:
filter = Project.private == False # noqa
elif not user.admin:
query = query.outerjoin(Project.allowed_users)
filter = or_(
Project.private == False, # noqa
User.id == user_id)
else:
filter = True # make it work with an and_ filter
if 'search' in request.params:
s = request.params.get('search')
PT = ProjectTranslation
search_filter = or_(
PT.name.ilike('%%%s%%' % s),
PT.short_description.ilike('%%%s%%' % s),
PT.description.ilike('%%%s%%' % s),
)
ids = DBSession.query(ProjectTranslation.id) \
.filter(search_filter) \
.all()
filter = and_(Project.id.in_(ids), filter)
sort_by = 'project.%s' % request.params.get('sort_by', 'priority')
direction = request.params.get('direction', 'asc')
direction_func = getattr(sqlalchemy, direction, None)
sort_by = direction_func(sort_by)
query = query.order_by(sort_by, desc(Project.created))
query = query.filter(filter)
# join tables so that new queries are not done when parsing template
query = query.options(joinedload(Project.translations)) \
.options(joinedload(Project.area))
projects = query.all()
page = int(request.params.get('page', 1))
page_url = PageURL_WebOb(request)
paginator = Page(projects, page, url=page_url, items_per_page=10)
return dict(page_id="home", paginator=paginator)
def get_search(cls, request, searchterm, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
query = DBSession.query(Question, Qvote, Images).outerjoin(
Images, Images.usralias == Question.askedbyalias).outerjoin(
Qvote,
and_(Question.questionasker == Qvote.questionasker,
Qvote.userid == logged_in_alias))
query = search(query, searchterm)
return Page(query, page, url=page_url, items_per_page=20)
def stream_top(cls, request, followinglist, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
try:
followinglist = followinglist.lower()
followinglist = followinglist.split()
except:
followinglist = ""
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin(Qvote, and_(Question.questionasker==Qvote.questionasker,Qvote.userid == logged_in_alias)).filter(Question.askedtoalias.in_\
(followinglist)).order_by(sa.desc(Question.qkarma)), page,
url=page_url, items_per_page=20)
def userlog(request):
users = DBSession.query(AuthUserLog).order_by(
AuthUserLog.time.desc()).all()
title = 'Users logs'
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(users, page=page, items_per_page=10, url=page_url)
if page > 1:
title = title + ' page ' + str(page)
return dict(paginator=paginator, title=title)
def users(request):
users = DBSession.query(User).all()
users.sort(key=lambda user: user.username)
users.sort(key=lambda user: user.is_admin or user.is_project_manager,
reverse=True)
page = int(request.params.get('page', 1))
page_url = PageURL_WebOb(request)
paginator = Page(users, page, url=page_url, items_per_page=40)
return dict(page_id="users", users=users, paginator=paginator)
def getZoomifyCollectionForBlattnr(request, blattnr, session, page=1):
coll = []
mtbs = Messtischblatt.allForBlattnr(blattnr, session)
for mtb in mtbs:
metadata = MdCore.by_id(mtb.id, session)
if mtb.mdtype == 'M' and mtb.istaktiv and not mtb.isttransformiert and mtb.hasgeorefparams == 0:
item = {'mtbid':mtb.id,'layername':mtb.dateiname,'titel':metadata.titel,'titel_short':metadata.titel_short,
'zoomify_prop':mtb.zoomify_properties,'zoomify_width':mtb.zoomify_width,'zoomify_height':mtb.zoomify_height}
coll.append(item)
# create paginator
page_url = PageURL_WebOb(request)
return Page(coll, page, url=page_url, items_per_page=10)
def stream_hot(cls, request, followinglist, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
try:
followinglist = followinglist.lower()
followinglist = followinglist.split()
except:
followinglist = ""
now = int(round(time.time() / 60 / 60)) + 1
gravity = 1.8
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin(Qvote, and_(Question.questionasker==Qvote.questionasker,Qvote.userid == logged_in_alias)).filter(Question.askedtoalias.in_\
(followinglist)).order_by(sa.desc((Question.qkarma -1) /\
func.pow((now - Question.unixage), gravity))), page,
url=page_url, items_per_page=20)
def users(request):
users = DBSession.query(User).order_by(User.username)
roles = [int(role) for role in request.params.getall('role')]
if len(roles):
for role in roles:
users = users.filter(User.role.op('&')(role) != 0)
page = int(request.params.get('page', 1))
page_url = PageURL_WebOb(request)
paginator = Page(users, page, url=page_url, items_per_page=40)
return dict(page_id="users", paginator=paginator)
def get_paginator_forBlattnr(cls, request, blattnr, page=1):
page_url = PageURL_WebOb(request)
return Page([{
'mtbid': 1
}, {
'mtbid': 2
}, {
'mtbid': 3
}, {
'mtbid': 4
}],
page,
url=page_url,
items_per_page=10)
def adminlistsearch(self):
title = 'Unapproved Listings'
listings = DBSession.query(Listings).filter(
Listings.approved == False).filter(
Listings.declined == False).all()
page_url = PageURL_WebOb(self.request)
paginator = Page(listings,
page=int(self.request.params.get("page", 1)),
items_per_page=5,
url=page_url)
return dict(paginator=paginator, title=title)
def ref(self):
title = "My Referrals"
user = self.request.user
reflink = self.request.route_url('home') + "?refid=" + user.serial
page = int(self.request.params.get('page', 1))
page_url = PageURL_WebOb(self.request)
paginator = Page(user.children,
page=page,
items_per_page=20,
url=page_url)
return dict(user=user,
title=title,
reflink=reflink,
paginator=paginator)
def user_favourites(self):
path = self.request.matchdict['prefix']
user = Users.get_by_path(path)
form = Form(self.request)
listings = user.favourites
title = "%s Saved Properties" % user.fullname
page_url = PageURL_WebOb(self.request)
page = int(self.request.params.get("page", 1))
paginator = Page(listings, page=page, items_per_page=10, url=page_url)
return dict(user=user,
paginator=paginator,
form=FormRenderer(form),
saved='saved',
title=title)
def viewstate(request):
state_id = request.matchdict['state_id']
state = State.get_by_id(state_id)
title = "Viewing %s" %(state.name)
lgas = DBSession.query(LGA).filter(LGA.state_id ==state_id).order_by(LGA.name).all()
page_url = PageURL_WebOb(request)
paginator = Page(lgas,
page=int(request.params.get("page", 1)),
items_per_page=20,
url=page_url)
return dict(
state=state,
paginator = paginator,
title=title
)
def userblog(self):
path = self.request.matchdict['prefix']
user = Users.get_by_path(path)
blogs = DBSession.query(Blogs).filter(Blogs.user == user).filter(
Blogs.status == True).all()
form = Form(self.request)
title = user.fullname + "'s Blogs"
page_url = PageURL_WebOb(self.request)
page = int(self.request.params.get('page', 1))
paginator = Page(blogs, page=page, url=page_url)
return dict(user=user,
paginator=paginator,
form=FormRenderer(form),
bl='bl',
title=title)
