def update_personal(self):
user = self.request.user
form = Form(self.request, schema=PersonalSchema, obj=user)
if 'personal_submitted' in self.request.POST and form.validate():
form.bind(user)
DBSession.add(user)
if form.data['prefix'] and form.data['prefix'] != user.prefix:
user.prefix = create_path(form.data['prefix'], is_unique)
DBSession.flush()
if self.request.is_xhr:
html = """<div class="alert alert-success alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update Successful
</div>"""
return Response(html)
self.request.session.flash("success; Update successful")
return HTTPFound(location=self.request.route_url("user_edit"))
if self.request.is_xhr:
html = """<div class="alert alert-danger alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update Not Successful
</div>"""
return Response(html)
self.request.session.flash("success; Update successful")
return HTTPFound(location=self.request.route_url("user_edit"))
def ratings(self):
form = Form(self.request, schema=UserRatingSchema)
prefix = self.request.matchdict['prefix']
user = Users.get_by_path(prefix)
title = 'Rate ' + user.fullname
if 'form_submitted' in self.request.POST and form.validate():
if user.id == self.request.user.id:
self.request.session.flash("danger; You can't rate yourself")
return HTTPFound(
location=self.request.route_url('profile', prefix=prefix))
if user.rating:
for rating in user.rating:
if rating.rater_id == self.request.user.id:
self.request.session.flash(
"warning; You have rated %s before" %
user.fullname)
return HTTPFound(location=self.request.route_url(
'profile', prefix=prefix))
rating = UserRating(rater_id=self.request.user.id,
rated_id=user.id,
rating=form.data['rating'],
review=form.data['review'])
DBSession.add(rating)
DBSession.flush()
self.request.session.flash("success; Success")
return HTTPFound(
location=self.request.route_url('profile', prefix=prefix))
self.request.session.flash("danger; An Error occured")
return HTTPFound(
location=self.request.route_url('profile', prefix=prefix))
def populate_userTypes():
usertypes = [u'Buyer/Seller',u'Real Estate Developer/Builder',u'Real Estate Agent',u'Mortgage Lender',u'LandLord',
u'Real Estate Broker',u'Property Manager',u'Other/just Looking']
with transaction.manager:
for name in usertypes:
typs = User_types(
name)
DBSession.add(typs)
def listplans(request):
plans = DBSession.query(Plans).order_by(Plans.id).all()
form = Form(request, schema=PlanSchema())
if 'form_submitted' in request.POST and form.validate():
plan = form.bind(Plans())
DBSession.add(plan)
DBSession.flush()
return HTTPFound(location=request.route_url('list_plans'))
return dict(form=FormRenderer(form), plans=plans, title="List of plans")
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 populate_location():
states=[u"Abuja",u"Abia",u"Anambra",u"Adamawa",u"Akwa Ibom",u"Bauchi",u"Benue",
u"Bayelsa",u"Borno",u"Cross River",u"Enugu",u"Ebonyi",u"Edo",u"Ekiti",u"Delta",
u"Gombe",u"Imo",u"Jigawa",u"Kebbi",u"Kogi",u"Kwara",u"Kano",u"Kaduna",u"Katsina",
u"Lagos",u"Nasarawa",u"Niger",u"Osun",u"Ogun",u"Oyo",u"Ondo",u"Rivers",u"Plateau",
u"Taraba",u"Sokoto",u"Yobe",u"Zamfara"]
with transaction.manager:
for state in states:
s = State(state)
DBSession.add(s)
def editplans(request):
pid = request.matchdict.get('id')
plan = DBSession.query(Plans).get(pid)
form = Form(request, schema=PlanSchema(), obj=plan)
if 'form_submitted' in request.POST and form.validate():
form.bind(plan)
DBSession.add(plan)
DBSession.flush()
return HTTPFound(location=request.route_url('list_plans'))
return dict(form=FormRenderer(form), plan=plan, title=plan.name + " Edit")
def edit_blog(self):
from buddy.models.properties_model import State
def get_states():
query = [(s.id, s.name) for s in DBSession.query(State).all()]
return query
name = self.request.matchdict['name']
categories = get_categories()
blog = Blogs.get_by_name(name)
if not blog:
self.session.flash("danger; No such blog post")
return HTTPFound(location=self.request.route_url('blog_list'))
title = "Editing " + blog.title
form = Form(self.request, schema=BlogPost, obj=blog)
if "form_submitted" in self.request.POST and form.validate():
form.bind(blog, exclude=['category_id'])
for i, cat in enumerate(blog.categories):
if cat.id not in form.data['category_id']:
del blog.categories[i]
catids = [cat.id for cat in blog.categories]
for cate in form.data['category_id']:
if cate not in catids:
t = DBSession.query(BlogCategory).get(cate)
blog.categories.append(t)
blog.status = True
DBSession.add(blog)
DBSession.flush()
return HTTPFound(
location=self.request.route_url('blog_view', name=blog.name))
elif "draft" in self.request.POST and form.validate():
form.bind(blog, exclude=['category_id'])
for i, cat in enumerate(blog.categories):
if cat.id not in form.data['category_id']:
del blog.categories[i]
catids = [cat.id for cat in blog.categories]
for cate in form.data['category_id']:
if cate not in catids:
t = DBSession.query(BlogCategory).get(cate)
blog.categories.append(t)
blog.status = 0
DBSession.add(blog)
DBSession.flush()
return HTTPFound(
location=self.request.route_url('blog_view', name=blog.name))
return {
'form': FormRenderer(form),
'blog_nav_cat': get_navcategories(),
'title': title,
'categories': categories,
'blog': blog,
'wb': 'wb',
'states': get_states()
}
def add_g(request):
title = 'Add group'
groups = DBSession.query(Groups).all()
form = Form(request, schema=AddGroup)
if 'form_submitted' in request.POST and form.validate():
group = form.bind(Groups())
DBSession.add(group)
DBSession.flush()
redir_url = request.route_url('dashboard')
return HTTPFound(location=redir_url)
return dict(form=FormRenderer(form), groups=groups, title=title)
def buddy_remember(request, user, event='L'):
if asbool(buddy_settings('log_logins')):
if buddy_settings('log_login_header'):
ip_addr = request.environ.get(
buddy_settings('log_login_header'),
u'invalid value - buddy.log_login_header')
else:
ip_addr = unicode(request.environ['REMOTE_ADDR'])
record = AuthUserLog(user_id=user.id, ip_addr=ip_addr, event=event)
DBSession.add(record)
DBSession.flush()
return remember(request, user.id)
return remember(request, user.id)
def verify(request):
prefix = request.matchdict['prefix']
user = Users.get_by_path(prefix)
if not user:
request.session.flash('danger; user not found')
user.is_verified = True
user_parent = user.parent
silver_plan = DBSession.query(Plans).filter(Plans.name == 'Silver').first()
if user_parent:
if not user_parent.earned_benefit:
if user.active_subscription:
active_sub = user.active_subscription[0]
subscription = Subscription(user=user,
plan=silver_plan,
amount=0,
no_of_months=1,
discount=u"100%",
status=u"Active")
subscription.start_date = active_sub.end_date
subscription.end_date = active_sub.end_date + timedelta(
days=30)
else:
subscription = Subscription(user=request.user,
plan=silver_plan,
amount=0,
no_of_months=1,
discount=u"100%",
start_date=datetime.today(),
end_date=datetime.today() +
timedelta(days=30),
status=u"Active")
DBSession.add(subscription)
DBSession.flush()
body = """<html><head><title>Verified on nairabricks.com</title></head><body>
<p>Dear %s,<p><br>
<p>You are now verified as a professional in Nairabricks</p>
<p>However, please note that we still have the right to decline your listings if they violate our property listing policy</p>
<p>Moreso, ensure that your listings are not duplicated.
Instead of having duplicate listings, update your listing frequently to keep it at the top</p>
<p>Yours sincerely,</p>
<p>The Happy Nairabricks Info Robot</p>
</body>
</html>
""" % user.fullname
html_email_sender(request,
subject="Congratulations",
recipients=user.email,
body=body)
request.session.flash('success; user verified')
return HTTPFound(location=request.route_url('user_list'))
def promo_sub(request):
id = request.matchdict['id']
user = Users.get_by_id(id)
if not user:
return HTTPNotFound()
form = Form(request, schema=PromoSubSchema)
if 'submit' in request.POST and form.validate():
plan_id = form.data['plan']
plan = DBSession.query(Plans).get(plan_id)
if plan:
subscription = Subscription(user=user,
plan=plan,
amount=0,
no_of_months=1,
discount="100%",
status="Active",
start_date=datetime.today(),
end_date=datetime.today() +
timedelta(days=30))
DBSession.add(subscription)
DBSession.flush()
if request.is_xhr:
html = """<div class="alert alert-success alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
User subscription
</div>"""
return Response(html)
request.session.flash('success; User subscribed')
return HTTPFound(
location=request.route_url('profile', prefix=user.prefix))
if request.is_xhr:
html = """<div class="alert alert-danger alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
An error occured, user Not subscribed
</div>"""
return Response(html)
request.session.flash('danger; An error occured, user subscribed %s' %
form.all_errors())
return HTTPFound(
location=request.route_url('profile', prefix=user.prefix))
if request.is_xhr:
html = """<div class="alert alert-danger alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
An error occured, user Not subscribed
</div>"""
return Response(html)
request.session.flash('danger; An error occured, user subscribed %s' %
form.all_errors())
return HTTPFound(location=request.route_url('profile', prefix=user.prefix))
def listing_category_edit(request):
"""listing category edit """
title = 'Edit listing category'
id = request.matchdict['id']
dbsession = DBSession()
category = PropertyCategory.get_by_id(id)
if category is None:
request.session.flash("warning; Category not found!")
return HTTPFound(location=request.route_url("listing_category_list"))
form = Form(request, schema=BlogCategoryForm, obj=category)
if "form_submitted" in request.POST and form.validate():
form.bind(category)
dbsession.add(category)
request.session.flash("success;The Category is saved!")
return HTTPFound(location=request.route_url("listing_category_list"))
action_url = request.route_url("listing_category_edit", id=id)
return dict(form=FormRenderer(form), action_url=action_url)
def view_p(self):
name = self.request.matchdict['name']
listing = Listings.get_by_name(name)
if not listing:
self.request.session.flash('warning; Listing not found')
return HTTPFound(location=self.request.route_url('home'))
form = Form(self.request)
files = listing.pictures.all()
#city = DBSession.query(Locality).filter(Locality.state_id==listing.state_id).\
# filter(Locality.city_name==listing.city).first()
category = listing.property_extra
'''
receiver = listing.user.email
body = """
<html><head></head><body>
<p>Dear %s,<p><br>
<p>A user at Nairabricks viewed your property <a href="%s">%s</a> just now.</p>
<p>Yours sincerely,</p>
<p>The Happy Nairabricks Info Robot</p>
</body>
</html>
"""%(listing.user.fullname,self.request.route_url('property_view',name=name),listing.serial)
if not self.request.user==listing.user:
html_email_sender(self.request,
subject = "Property Clicks",
recipients=receiver,
body = body
)
'''
view_log = Content_Stat(content_id=listing.id, views=1)
DBSession.add(view_log)
DBSession.flush()
return dict(files=files,
title=listing.title,
form=FormRenderer(form),
category=category,
listing=listing
#, locality=city
)
def view_blog(self):
name = self.request.matchdict['name']
blog = Blogs.get_by_name(name)
if not blog:
self.session.flash("danger; No such blog post")
return HTTPFound(location=self.request.route_url('blog_list'))
title = blog.title
bcategor = DBSession.query(Blogs).filter(
Blogs.user_id == blog.user.id).all()
bc = [s.categories for s in bcategor]
bc = histogram(bc)
view_log = Content_Stat(content_id=blog.id, views=1)
DBSession.add(view_log)
DBSession.flush()
return dict(blog=blog,
user=blog.user,
title=title,
blog_nav_cat=get_navcategories(),
bcategories=bc)
def abt_update(self):
user = self.request.user
form = Form(self.request, schema=NoteSchema, obj=user)
if "abt_submitted" in self.request.POST and form.validate():
form.bind(user)
DBSession.add(user)
DBSession.flush()
if self.request.is_xhr:
html = """<div class="alert alert-success alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update Successful
</div>"""
return Response(html)
self.session.flash("success; Update successful")
return HTTPFound(location=self.request.route_url("user_edit"))
if self.request.is_xhr:
html = """<div class="alert alert-danger alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update Not Successful
</div>"""
return Response(html)
self.session.flash("danger; Update Not successful")
return HTTPFound(location=self.request.route_url("user_edit"))
def email_passw(request):
user = request.user
form = Form(request, schema=ChangeEmailPassword, obj=user)
if 'pass_submitted' in request.POST and form.validate():
form.bind(user)
DBSession.add(user)
DBSession.flush()
if request.is_xhr:
html = """<div class="alert alert-success alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update Successful
</div>"""
return Response(html)
request.session.flash("success; Email and password saved")
return HTTPFound(location=request.route_url('account'))
if request.is_xhr:
html = """<div class="alert alert-danger alert-dismissable col-xs-12">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
Update not Successful {0}
</div>""".format(form.all_errors())
return Response(html)
request.session.flash("danger; Update not successful")
return HTTPFound(location=request.route_url('account'))
def blog_category_add(request):
title = 'Add blog category'
parent_categories = DBSession.query(BlogCategory).filter(
BlogCategory.parent == None).all()
parent_categories = [(x.id, x.name) for x in parent_categories]
form = Form(request, schema=BlogCategoryForm)
if "form_submitted" in request.POST and form.validate():
#add
category = BlogCategory(name=form.data['name'],
description=form.data['description'],
parent=form.data['parent'])
DBSession.add(category)
DBSession.flush()
request.session.flash('success; category saved')
return HTTPFound(location=request.route_url("blog_category_list"))
action_url = request.route_url('add_blog_category')
return {
'form': FormRenderer(form),
'title': title,
'action_url': action_url,
'parent_categories': parent_categories
}
def blog_category_edit(request):
title = 'Edit blog category'
id = request.matchdict['id']
parent_categories = DBSession.query(BlogCategory).filter(
BlogCategory.parent == None).all()
parent_categories = [(x.id, x.name) for x in parent_categories]
category = BlogCategory.get_by_id(id)
if category is None:
request.session.flash("warning; Category not found!")
return HTTPFound(location=request.route_url("blog_category_list"))
form = Form(request, schema=BlogCategoryForm, obj=category)
if "form_submitted" in request.POST and form.validate():
form.bind(category)
DBSession.add(category)
request.session.flash("success;The Category is saved!")
return HTTPFound(location=request.route_url("blog_category_list"))
action_url = request.route_url("blog_category_edit", id=id)
return dict(form=FormRenderer(form),
category=category,
parent_categories=parent_categories,
action_url=action_url)
def populate_features():
external = Feature_types(u'External Features')
internal = Feature_types(u'Internal Features')
eco = Feature_types(u'Eco Features')
other = Feature_types(u'Other Features')
oth = [u'Pets Allowed', u'Disability Features',u'Waterfront', u'Water View',
u'Ocean View', u'River View',u'Hill/Mountain View', u'Development Projects']
inter = [u'Alarm System', u'Intercom',u'Ensuite', u'Dishwasher',
u'Built-in wardrobes', u'Ducted vacuum system',u'Gym', u'Indoor spa',
u'Floorboards', u'Broadband internet available',u'Pay TV access', u'Fireplace',
u'Ducted', u'heating', u'Ducted cooling',u'Split-system heating',
u'Hydronic heating',u'Air conditioning', u'Gas heating',u'Lift']
ext =[u'Carport', u'Garage',u'Open car spaces', u'Remote garage',
u'Secure parking', u'Swimming pool',u'Tennis court', u'Balcony',
u'Deck', u'Courtyard',u'Outdoor entertaining area', u'Fully fenced']
ec = [u'Solar panels', u'Solar hot water',u'Water tank', u'Grey water system',
u'High Energy efficiency rating', u'Medium Energy efficiency rating',
u'Low - Energy efficiency rating']
with transaction.manager:
for c in inter:
indoor = Features(name=c)
DBSession.add(indoor)
internal.features.append(indoor)
for e in ext:
outdoor = Features(name=e)
DBSession.add(outdoor)
external.features.append(outdoor)
for i in ec:
ecof = Features(name=i)
DBSession.add(ecof)
eco.features.append(ecof)
for o in oth:
othr = Features(name=o)
DBSession.add(othr)
other.features.append(othr)
DBSession.add_all([external,internal,eco])
transaction.commit()
def subscribe_plan(request):
name = request.matchdict['name']
type = request.matchdict['type']
plan = DBSession.query(Plans).filter(Plans.name == name).first()
title = plan.name + " Plan subscription"
form = Form(request, schema=PaymentSchema)
if 'submit' in request.POST and form.validate():
duration = form.data['duration']
amount = duration * plan.price_per_month
discount_percent = "-"
if 5 < duration < 12:
# total amount to pay
total = duration * plan.price_per_month
# 5% discount since it is more than 5 and less than 12
discount = total * 0.05
# resultant amount to pay is now:
amount = total - discount
discount_percent = u"5%"
elif duration == 12:
# total amount to pay
total = duration * plan.price_per_month
# 10% discount since it is 12 months
discount = total * 0.1
# resultant amount to pay is now:
amount = total - discount
discount_percent = u"10%"
paystack_secret_key = buddy_settings("paystack_secret_key")
paystack = Paystack(secret_key=paystack_secret_key)
#Renew
if type == "Renew":
# get active subscription
# set it to Expired. set the expiration date to today
# set new subscription expiration date to old active subscription expiration date + one month +2days
active_sub = request.user.active_subscription[0]
subscription = Subscription(user=request.user,
plan=plan,
amount=amount,
no_of_months=duration,
discount=discount_percent,
start_date=datetime.today())
DBSession.add(subscription)
subscription.end_date = active_sub.end_date + timedelta(
days=duration * 30 + 2)
active_sub.status = u"Expired"
else:
subscription = Subscription(user=request.user,
plan=plan,
amount=amount,
no_of_months=duration,
discount=discount_percent,
start_date=datetime.today(),
end_date=datetime.today() +
timedelta(days=duration * 30))
DBSession.add(subscription)
DBSession.flush()
callback_url = request.route_url('subscription_success',
reference=subscription.reference)
try:
response = paystack.transaction.initialize(
email=request.user.email,
callback_url=callback_url,
amount=str(int(amount)) + "00",
reference=subscription.reference)
except requests.exceptions.ConnectionError:
request.session.flash('info; Not enough Network')
return HTTPFound(location=request.route_url('pricing'))
if response['status']:
authorization_url = response['data']['authorization_url']
return Response(status_int=302, location=authorization_url)
return dict(form=FormRenderer(form), title=title, plan=plan, type=type)
def add_blog(self):
title = "Write a blog post"
user = self.request.user
if user is None:
self.request.session.flash('info; Not signed in, Please sign in')
return HTTPFound(location=self.request.route_url('login'))
if not self.request.user.email_verified:
return HTTPFound(
location=self.request.route_url('confirm_mail_holder'))
dbsession = DBSession()
from deform.widget import OptGroup
def get_categories_inside():
p = DBSession.query(BlogCategory).all()
c = []
for category in p:
if category.children:
g = [category.name]
d = [(child.id, child.name) for child in category.children]
for i in d:
g.append(i)
c.append(OptGroup(*tuple(g)))
return c
choices = tuple(get_categories_inside())
class BlogSchema(CSRFSchema):
title = colander.SchemaNode(colander.String(),
title="Title of blog post",
widget=deform.widget.TextInputWidget(
css_class="form-control required"))
category_id = colander.SchemaNode(
colander.Set(),
title="Categorize your blog post",
widget=deform.widget.SelectWidget(values=choices,
multiple=True,
css_class="required"))
body = colander.SchemaNode(colander.String(),
title="Body",
widget=deform.widget.TextAreaWidget(
css_class="required",
id="editor",
rows="10"))
#state_id = colander.SchemaNode(
# colander.String(),
# title = "State",
# missing=u'',
# widget = deform.widget.SelectWidget(values=get_states(),
# css_class="required")
# )
# city = colander.SchemaNode(
# colander.String(),
# title = "City",
# missing=u'',
# widget = deform.widget.TextInputWidget(css_class="required")
# )
def validator(form, value):
if len(value['category_id']) > 8:
exc = colander.Invalid(form, 'Categories must be less than 8')
exc['category_id'] = 'Categories must be less than 8'
raise exc
button = deform.Button(name="submit",
title="Publish",
css_class="btn btn-primary pull-right")
button2 = deform.Button(name="draft",
title="Save as Draft",
css_class="btn btn-warning pull-left")
schema = BlogSchema(validator=validator).bind(request=self.request)
rform = deform.Form(schema,
buttons=(button, button2),
bootstrap_form_style='form-horizontal')
form = rform.render()
if 'submit' in self.request.POST:
controls = self.request.POST.items() # get the form controls
try:
appstruct = rform.validate(controls) # call validate
except deform.ValidationFailure, e:
return {'form': e.render(), 'title': title}
blog = Blogs(
user=self.request.user,
name=urlify_name(appstruct['title']),
title=appstruct['title'],
body=appstruct['body']
#state_id = appstruct['state_id']
#city = appstruct['city']
)
for category in appstruct['category_id']:
t = DBSession.query(BlogCategory).get(category)
blog.categories.append(t)
blog.status = True
dbsession.add(blog)
#non_html_email_sender(
# self.request,
# recipients=["*****@*****.**"],
# subject="Blog post added on site",
# body="A user published a blog right now"
#)
dbsession.flush()
return HTTPFound(
location=self.request.route_url('blog_view', name=blog.name))