def share(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
if not self.plan_allow_realestatefriendship:
self.set_warning(
u'Su plan no tiene acceso al servicio de la red de inmobiliarias de ULTRAPROP que le permite ampliar su oferta y compartirla con sus colegas. Comuníquese con Ultraprop si desea utilizarlo.'
)
return self.redirect_to('property/list')
req = get_or_404(kwargs.get('key'))
if str(realestate.key()) not in req.realestates:
self.abort(500)
if req.is_sender(realestate):
req.rs_a_shows_b = True
else:
req.rs_b_shows_a = True
req.save()
my_key = self.get_realestate_key()
owner = req.get_the_other_realestate(my_key, key_only=True)
# logging.error(u'realestatebook::share() owner:%s friend:%s'%(owner, my_key));
tmp = NetworkPropertyMapper(owner,
my_key,
do_add=True,
for_admin=False,
for_website=True)
deferred.defer(tmp.run)
realestate_b = req.get_the_other_realestate(my_key, key_only=False)
context = {
'rs':
realestate,
'rs_other':
realestate_b,
'rs_other_not_sharing':
req.is_the_other_realestate_offering_my_props(my_key)
}
body = self.render_template('email/realestate_friend_is_sharing.txt',
**context)
html = self.render_template('email/realestate_friend_is_sharing.html',
**context)
# Envío el correo.
mail.send_mail(
sender="www.ultraprop.com.ar <%s>" %
self.config['ultraprop']['mail']['share_link']['sender'],
to=realestate_b.email,
subject=u"ULTRAPROP - Red ULTRAPROP",
body=body,
html=html)
self.set_ok('La amistad ha sido actualizada.')
return self.redirect_to('backend/realestatebook/friends')
def accept_or_reject(self, accept=True, **kwargs):
realestate = get_or_404(self.get_realestate_key())
req = get_or_404(kwargs.get('key'))
if req.is_sender(realestate):
self.abort(500)
my_key = self.get_realestate_key()
realestate_b = req.get_the_other_realestate(my_key, key_only=False)
context = {'rs_requestor': realestate_b, 'rs_receiver': realestate}
if accept:
req.accept()
# Si yo acepto, es porque me invito ela otra inmobiliaria, por lo que owner is the other RS!
owner = req.get_the_other_realestate(my_key, key_only=True)
tmp = NetworkPropertyMapper(owner,
my_key,
do_add=True,
for_admin=True,
for_website=False)
deferred.defer(tmp.run)
tmp2 = NetworkPropertyMapper(my_key,
owner,
do_add=True,
for_admin=True,
for_website=False)
deferred.defer(tmp2.run)
body = self.render_template('email/realestate_friend_accepted.txt',
**context)
html = self.render_template(
'email/realestate_friend_accepted.html', **context)
# Envío el correo.
mail.send_mail(
sender="www.ultraprop.com.ar <%s>" %
self.config['ultraprop']['mail']['share_link']['sender'],
to=realestate_b.email,
subject="ULTRAPROP - Pedido de amistad",
body=body,
html=html)
self.set_ok('La solicitud de amistad ha sido aceptada.')
else:
# body = self.render_template('email/realestate_friend_denied.txt', **context)
# html = self.render_template('email/realestate_friend_denied.html', **context)
req.reject()
self.set_ok('La solicitud de amistad ha sido rechazada.')
return self.redirect_to('backend/realestatebook/requests')
def post(self, **kwargs):
self.request.charset = 'utf-8'
user = get_or_404(kwargs.get('key'))
email = self.request.POST.get('useremail', default=None)
password = self.request.POST.get('password', default=None)
confirm_password = self.request.POST.get('confirm', default=None)
if user.email != email:
self.set_error('Verifique el correo electrónico.')
return self.redirect_to('/restore/password/' + str(user.key()))
if password != confirm_password:
self.set_error('Las contraseñas no son iguales.')
return self.redirect_to('/restore/password/' + str(user.key()))
user.password = password
user.restore_password = 0
user.enabled = 1
user.save()
self.set_ok(
u'Su contraseña ha sido modificada satisfactoriamente.<br/>Ya puede ingresar a DirectoDueno.com con la nueva contraseña!'
)
return self.redirect_to('backend/auth/login')
def full_page(self, **kwargs):
key = kwargs['key']
price_data_operation = kwargs['oper']
property = get_or_404(key)
price = property.price_sell
cur = property.price_sell_currency
if int(price_data_operation) == Property._OPER_RENT:
price = property.price_rent
cur = property.price_rent_currency
context = {
'property': property,
'Property': Property,
'price': price,
'cur': cur,
'config_array': config_array,
'price_data_operation': price_data_operation
}
context_ex = dict({'form': self.form}, **context)
context_ex = dict(
{
'images':
ImageFile.all().filter('property =',
db.Key(key)).order('position')
}, **context_ex)
return self.render_response('frontend/ficha.html', **context_ex)
def get2(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
if not self.plan_allow_realestatefriendship:
self.set_warning(
u'Su plan no tiene acceso al servicio de la red de inmobiliarias de ULTRAPROP que le permite ampliar su oferta y compartirla con sus colegas. Comuníquese con Ultraprop si desea utilizarlo.'
)
return self.redirect_to('property/list')
kwargs['realestate'] = realestate
kwargs['mnutop'] = 'realestatebook'
# if 'filter' not in kwargs or kwargs['filter']==0:
# kwargs['requests'] = RealEstateFriendship.all().filter('realestates = ', str(realestate.key())).filter('state ', RealEstateFriendship._REQUESTED).fetch(1000)
# kwargs['filter'] = 0
# else:
if kwargs['filter'] == self._SENT:
kwargs['requests'] = RealEstateFriendship.all().filter(
'realestate_a = ',
realestate.key()).filter('state in ', [
RealEstateFriendship._REQUESTED,
RealEstateFriendship._DENIED
]).fetch(1000)
else:
kwargs['requests'] = RealEstateFriendship.all().filter(
'realestate_b = ', realestate.key()).filter(
'state = ', RealEstateFriendship._REQUESTED).fetch(1000)
kwargs['_SENT'] = self._SENT
kwargs['_RECEIVED'] = self._RECEIVED
return self.render_response('backend/realestatebook_requests.html',
**kwargs)
def post(self, **kwargs):
self.request.charset = 'utf-8'
realestate = get_or_404(self.get_realestate_key())
#HACK: Hack? le pongo un miembro para que la validacion del slug sepa cual es la key actual de la RealEste
#de otra forma va a decir que ya esta siendo utilizada
self.form.thekey = self.get_realestate_key()
rs_validated = self.form.validate()
if not rs_validated:
kwargs['form'] = self.form
kwargs['key'] = self.get_realestate_key()
kwargs['realestate_logo'] = realestate.logo_url
if self.form.errors:
kwargs['flash'] = self.build_error(u'Verifique los datos ingresados:')
# + '<br/>'.join(reduce(lambda x, y: str(x)+' '+str(y), t) for t in self.form.errors.values()))
return self.render_response('backend/realestate.html', **kwargs)
realestate = self.form.update_object(realestate)
realestate.save()
# Actualizo los cambios en la sesión.
self.do_login(db.get(self.get_user_key()))
# Set Flash
self.set_ok('Inmobiliaria guardada satisfactoriamente.')
if self.request.POST['goto'] == 'website':
return self.redirect_to('backend/realestate_website/edit')
return self.redirect_to('backend/realestate/edit')
def post(self, **kwargs):
self.request.charset = 'utf-8'
realestate = get_or_404(self.get_realestate_key())
rs_validated = self.form.validate()
if not rs_validated:
kwargs['form'] = self.form
kwargs['mnutop'] = 'help'
if self.form.errors:
kwargs['flash'] = self.build_error(
u'Verifique los datos ingresados:')
# + '<br/>'.join(reduce(lambda x, y: str(x)+' '+str(y), t) for t in self.form.errors.values()))
return self.render_response('backend/help.html', **kwargs)
helpdesk = HelpDesk()
helpdesk.realestate = realestate
helpdesk.realestate_name = realestate.name
helpdesk = self.form.update_object(helpdesk)
mail_to = '*****@*****.**'
body = 'El usuario %s solicita ayuda. Key: %s. MSG" "%s"' % (
realestate.email, str(realestate.key()), helpdesk)
mail.send_mail(sender="www.directodueno.com <*****@*****.**>",
to=mail_to,
subject="DirectoDueño: Un cliente necesita ayuda",
body=body)
helpdesk.save()
# Set Flash
self.set_ok(
u'Su solicitud fue enviada satisfactoriamente.<br/> A la brevedad un agente de DirectoDueño se comunicará con Ud.'
)
return self.redirect_to('backend/help')
def get(self, **kwargs):
user = get_or_404(kwargs.get('key'))
if user.enabled == 0 and user.restore_password == 1:
user.restore_password = 0
user.enabled = 1
user.save()
self.set_ok('Su cuenta ha sido actualizada satisfactoriamente!')
return self.redirect_to('backend/auth/login')
def get(self, **kwargs):
self.realestate = get_or_404( self.get_realestate_key_ex(kwargs.get('realestate')) )
# Ponemos la pantalla de disabled si esta en NO_PAYMENT
if self.realestate.status == RealEstate._NO_PAYMENT or self.realestate.plan.allow_website == 0:
return self.render_response('realestate/disabled.html', realestate=self.realestate)
return self.get2(**kwargs)
def get(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
kwargs['form'] = RealEstateForm(obj=realestate)
kwargs['key'] = self.get_realestate_key()
kwargs['mnutop'] = 'inmobiliaria'
kwargs['realestate_logo'] = realestate.logo_url
return self.render_response('backend/realestate.html', **kwargs)
def star(cid,starred='t'):
"star or unstar a crowd"
#FIXME: this should verify that it was a POST
crowd = get_or_404(Crowd,cid)
starred = parse_bool(starred)
if starred!=crowd.star:
crowd.star = starred
crowd.save()
return crowd.simple()
def star(cid, starred='t'):
"star or unstar a crowd"
#FIXME: this should verify that it was a POST
crowd = get_or_404(Crowd, cid)
starred = parse_bool(starred)
if starred != crowd.star:
crowd.star = starred
crowd.save()
return crowd.simple()
def get(self):
# sort books by author
if request.args.get('author'):
author = get_or_404(Author, name=request.args.get('author'))
books = author.books
# get all books
else:
books = session.query(Book).all()
return render_template('index.haml', books=books)
def get(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
kwargs['form'] = RealEstateWebSiteForm(obj=realestate)
kwargs['key'] = self.get_realestate_key()
kwargs['realestate'] = realestate
kwargs['mnutop'] = 'website'
return self.render_response('backend/realestate_website.html',
themes=themes.keys(),
**kwargs)
def get(self, **kwargs):
kwargs['mnutop'] = 'realestatebook'
realestate = get_or_404(self.get_realestate_key())
if not self.plan_allow_realestatefriendship:
self.set_warning(
u'Su plan no tiene acceso al servicio de la red de inmobiliarias de ULTRAPROP que le permite ampliar su oferta y compartirla con sus colegas. Comuníquese con Ultraprop si desea utilizarlo.'
)
return self.redirect_to('property/list')
keys = [realestate.key()]
friends = RealEstateFriendship.all(keys_only=True).filter(
'realestates = ', str(realestate.key())).filter(
'state = ', RealEstateFriendship._ACCEPTED).fetch(1000)
requesteds = RealEstateFriendship.all(keys_only=True).filter(
'realestates = ', str(realestate.key())).fetch(1000)
realestate_str_key = str(realestate.key())
query = RealEstate.all().filter('__key__ != ', realestate.key())
if not self.has_role('ultraadmin'):
query.filter(' is_tester = ', False)
already_friends = []
if friends:
for request in friends:
current_key = RealEstateFriendship.get_the_other(
request, realestate_str_key, get_key=False)
already_friends.append(current_key)
denied = []
friend_req_sent = []
if requesteds:
for request in requesteds:
current_key = RealEstateFriendship.get_the_other(
request, realestate_str_key, get_key=False)
if current_key not in already_friends:
if RealEstateFriendship.is_sender_ex(
request, realestate_str_key):
friend_req_sent.append(current_key)
else:
if db.get(
request).state == RealEstateFriendship._DENIED:
denied.append(current_key)
else:
friend_req_sent.append(current_key)
kwargs['denied'] = denied
kwargs['already_friends'] = already_friends
kwargs['friend_req_sent'] = friend_req_sent
kwargs['realestates'] = query.fetch(1000)
return self.render_response('backend/realestatebook_search.html',
**kwargs)
def get(self, **kwargs):
user = get_or_404(kwargs.get('key'))
if user.enabled != 0 or user.restore_password != 1:
return self.render_response(
'error.html',
code=404,
text='No está habilitado para ejecutar este comando.')
kwargs['key'] = str(user.key())
kwargs['email'] = user.email
return self.render_response('backend/restore_password.html', **kwargs)
def theme_preview(self, **kwargs):
self.realestate = get_or_404(
self.get_realestate_key_ex(kwargs.get('realestate')))
if not self.realestate:
abort(404)
del (kwargs['realestate'])
if 'theme' in kwargs and kwargs.get('theme') in themes.keys():
#HACK!
self.realestate.web_theme = kwargs.get('theme')
return self.getto(realestate=self.realestate, **kwargs)
def render(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
kwargs['mnutop'] = 'consultas'
kwargs['Property'] = Property
kwargs['page_size'] = self.page_size
page = int(kwargs.get('page', '1'))
kwargs['consultas'], kwargs['page'] = self.get_items(
page=page, realestate=realestate)
kwargs['page'] = page
return self.render_response('backend/consultas.html', **kwargs)
def post(self, name):
print name
form = EditAuthorForm()
author = get_or_404(Author, name=name)
if form.validate():
if author.name != form.name.data:
author.name = form.name.data
try:
session.commit()
except:
session.rollback()
msg = 'Author <strong class=badge>{0}</strong> already \
exists!'.format(form.name.data)
flash(msg)
# return render_template('edit_author.haml', form=form, name=name)
return self.get(name)
new_books = str_separator(form.title.data)
old_books = get_books(author, format='list')
# get what to delete from exists books list and what to add, to bring
# to edited field books
rm_lst, append_lst = diff_list(old_books, new_books)
print(rm_lst, append_lst)
# remove not related books
for title in rm_lst:
b = get_or_404(Book, title=title)
author.books.remove(b)
if len(b.authors) == 1:
session.delete(b)
# relate new books with exist author
for title in append_lst:
b = get_or_create(Book, title=title)
author.books.append(b)
session.commit()
return redirect(url_for('index'))
return render_template('edit_author.haml', form=form, name=name)
def get(self, **kwargs):
re = get_or_404(kwargs['key'])
blobs = []
imgs = []
props = []
for img in ImageFile.all().filter('realestate', re.key()):
blobs.append(img.file.key())
imgs.append(img.key())
blobstore.delete(blobs)
db.delete(imgs)
props = []
for prop in Property.all().filter('realestate', re.key()):
props.append(prop.key())
db.delete(props)
pis = []
for pi in PropertyIndex.all().filter('realestate', re.key()):
pis.append(pi.key())
db.delete(pis)
invs = []
pays = []
for inv in Invoice.all().filter('realestate', re.key()):
invs.append(inv)
if inv.payment:
pays.append(inv.payment.key())
db.delete(invs)
db.delete(pays)
usrs = []
for usr in User.all().filter('realestate', re.key()):
usrs.append(usr)
db.delete(usrs)
mRealEstateFriendship = []
for fr in RealEstateFriendship.all().filter('realestates',
str(re.key())):
mRealEstateFriendship.append(fr)
db.delete(mRealEstateFriendship)
re.delete()
self.response.write('borrado %s' % kwargs['key'])
def post(self, title):
book = get_or_404(Book, title=title)
form = EditBookForm()
if form.validate():
if book.title != form.title.data:
book.title = form.title.data
try:
session.commit()
except:
session.rollback()
msg = 'Book <strong class=badge>{0}</strong> already \
exists!'.format(form.title.data)
flash(msg)
# return render_template('edit_book.haml', form=form, title=title)
return self.get(title)
# Get current and changed list of authors.
new_authors = str_separator(form.name.data)
old_authors = get_authors(book, format='list')
# We get authors' names which have to be deleted from an original list
# and also authors' names which have to be added.
rm_lst, append_lst = diff_list(old_authors, new_authors)
# remove not related authors
for name in rm_lst:
a = get_or_404(Author, name=name)
book.authors.remove(a)
if len(a.books) == 1:
session.delete(a)
# relate new authors with exist book
for name in append_lst:
a = get_or_create(Author, name=name)
book.authors.append(a)
session.commit()
return redirect(url_for('index'))
return render_template('edit_book.haml', form=form, title=title)
def delete(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
req = get_or_404(kwargs.get('key'))
if str(realestate.key()) not in req.realestates:
self.abort(500)
my_key = self.get_realestate_key()
owner = req.get_the_other_realestate(my_key, key_only=True)
tmp = NetworkPropertyMapper(owner,
my_key,
do_add=False,
for_admin=True,
for_website=True)
deferred.defer(tmp.run)
tmp2 = NetworkPropertyMapper(my_key,
owner,
do_add=False,
for_admin=True,
for_website=True)
deferred.defer(tmp2.run)
#Envío el correo.
realestate_b = db.get(owner)
context = {'rs': realestate, 'rs_other': realestate_b}
body = self.render_template('email/realestate_friend_deleted.txt',
**context)
html = self.render_template('email/realestate_friend_deleted.html',
**context)
mail.send_mail(
sender="www.ultraprop.com.ar <%s>" %
self.config['ultraprop']['mail']['share_link']['sender'],
to=realestate_b.email,
subject=u"ULTRAPROP - Finalización de amistad",
body=body,
html=html)
req.delete()
self.set_ok('Su Red ha sido actualizada satisfactoriamente.')
return self.redirect_to('backend/realestatebook/friends')
def set_theme(self, **kwargs):
self.request.charset = 'utf-8'
realestate = get_or_404(self.get_realestate_key())
the_theme = default_theme
if 'theme' in kwargs and kwargs.get('theme') in themes.keys():
the_theme = kwargs.get('theme')
realestate.web_theme = the_theme
realestate.save()
self.set_ok('Plantilla actualizada satisfactoriamente.')
return self.redirect_to('backend/realestate_website/edit')
def password(self, **kwargs):
user = get_or_404(self.get_user_key())
u_validated = self.change_password_form.validate()
if not u_validated:
kwargs['form'] = UserForm(obj=user)
kwargs['password_form'] = self.change_password_form
self.set_error('Verifique los datos ingresados:')
return self.render(user, **kwargs)
user = self.change_password_form.update_object(user)
user.save()
self.set_ok('Contraseña guardada satisfactoriamente.')
return self.redirect_to('backend/user/edit')
def on_post(self, request, response):
"""Create a new task.
Payload parameters:
title: str, required
Title of the task.
list_id: int, required
ID of the list to add this task to.
due_date: str, optional (default: '')
ISO date-time by which the task has to be done.
completed: bool, optional (default: False)
Whether this task is completed.
Priority: int, optional (default: 0)
How urgent is the task. The higher the more important.
Example response:
```
{
'id': 2,
'list_id': 2,
'title': 'Make a sandwich',
'due_date': null,
'completed': false,
priority: 0
}
```
"""
title = request.get_json('title')
list_id = request.get_json('list_id')
due_date = request.get_json('due_date', default=None)
completed = request.get_json('completed', dtype=bool, default=False)
priority = request.get_json('priority', dtype=int, default=0)
due_date = read_datetime(due_date)
list_ = get_or_404(self.session, List, id=list_id)
task = Task(
title=title,
list=list_,
due_date=due_date,
completed=completed,
priority=priority)
self.session.add(task)
self.session.commit()
response.status = falcon.HTTP_201
response.json = task.serialized
def get(self, **kwargs):
realestate = get_or_404(
self.get_realestate_key_ex(kwargs.get('realestate')))
# Ponemos la pantalla de disabled si esta en NO_PAYMENT
if realestate.status == RealEstate._NO_PAYMENT or realestate.plan.allow_website == 0:
return self.render_response('realestate/disabled.html',
realestate=realestate)
kwargs['realestate'] = realestate
kwargs['realestate_logo'] = realestate.logo_url
kwargs['menu_item'] = 'info'
kwargs['form'] = self.form
return self.render_response('realestate/contact.html', **kwargs)
def post(self, **kwargs):
self.request.charset = 'utf-8'
realestate = get_or_404(self.get_realestate_key())
#HACK: Hack? le pongo un miembro para que la validacion del slug sepa cual es la key actual de la RealEste
#de otra forma va a decir que ya esta siendo utilizada
self.form.thekey = self.get_realestate_key()
rs_validated = self.form.validate()
if not rs_validated:
kwargs['form'] = self.form
kwargs['key'] = self.get_realestate_key()
if self.form.errors:
kwargs['flash'] = self.build_error(
u'Verifique los datos ingresados:')
# + '<br/>'.join(reduce(lambda x, y: str(x)+' '+str(y), t) for t in self.form.errors.values()))
return self.render_response('backend/realestate_website.html',
themes=themes.keys(),
**kwargs)
realestate, requested_hosting = self.form.update_object(realestate)
realestate.save()
if requested_hosting:
mail_to = '*****@*****.**'
body = 'La inmobiliaria %s desea %shostearse en ULTRAPROP. Key: %s; - Name:%s; - Url:%s' % (
realestate.name, 'DES' if realestate.managed_domain == 0 else
'', str(realestate.key()), realestate.name,
self.url_for('realestate/search',
_full=True,
realestate=str(realestate.key())))
mail.send_mail(
sender="www.ultraprop.com.ar <*****@*****.**>",
to=mail_to,
subject=
"ULTRAPROP: Una inmobiliaria cambio su estado de hosting en ULTRAPROP",
body=body)
# Actualizo los cambios en la sesión.
self.do_login(db.get(self.get_user_key()))
# Set Flash
self.set_ok(
'Configuración de Sitio Web guardado satisfactoriamente. Un agente de ULTRAPROP se comunicará con Ud. en breve.'
)
return self.redirect_to('backend/realestate_website/edit')
def get(self, **kwargs):
realestate = get_or_404(self.get_realestate_key())
if not self.plan_allow_realestatefriendship:
self.set_warning(
u'Su plan no tiene acceso al servicio de la red de inmobiliarias de ULTRAPROP que le permite ampliar su oferta y compartirla con sus colegas. Comuníquese con Ultraprop si desea utilizarlo.'
)
return self.redirect_to('property/list')
kwargs['realestate'] = realestate
kwargs['mnutop'] = 'realestatebook'
kwargs['requests'] = RealEstateFriendship.all().filter(
'realestates = ', str(realestate.key())).filter(
'state = ', RealEstateFriendship._ACCEPTED).fetch(1000)
return self.render_response('backend/realestatebook_friends.html',
**kwargs)
def texts_preview(self, **kwargs):
self.request.charset = 'utf-8'
self.realestate = get_or_404(
self.get_realestate_key_ex(kwargs.get('realestate')))
if not self.realestate:
abort(404)
del (kwargs['realestate'])
if 'title' in kwargs:
#HACK!
self.realestate.tpl_title = kwargs.get('title').decode('utf-8')
if 'message' in kwargs:
#HACK!
self.realestate.tpl_text = kwargs.get('message').decode('utf-8')
return self.getto(realestate=self.realestate, **kwargs)
def get(self, **kwargs):
key = kwargs['key']
bubble_css = kwargs['bubble_css']
price_data_operation = int(kwargs['oper'])
property = get_or_404(key)
images = ImageFile.all().filter('property =',
db.Key(key)).order('position')
context = {
'images': images,
'property': property,
'Property': Property,
'bubble_css': bubble_css,
'price_data_operation': price_data_operation
}
return self.render_response('frontend/templates/_bubble.html',
**context)
def get(self, **kwargs):
realestate = get_or_404(
self.get_realestate_key_ex(kwargs.get('realestate')))
# Ponemos la pantalla de disabled si esta en NO_PAYMENT
if realestate.status == RealEstate._NO_PAYMENT or realestate.plan.allow_website == 0:
return self.render_response('realestate/disabled.html',
realestate=realestate)
kwargs['realestate'] = realestate
kwargs['realestate_logo'] = realestate.logo_url
key = kwargs['key']
price_data_operation = kwargs['oper']
property = db.get(key)
property.visits = property.visits + 1
property.save(build_index=False)
price = property.price_sell
cur = property.price_sell_currency
if int(price_data_operation) == Property._OPER_RENT:
price = property.price_rent
cur = property.price_rent_currency
kwargs['property'] = property
kwargs['Property'] = Property
kwargs['price'] = price
kwargs['cur'] = cur
kwargs['config_array'] = config_array
kwargs['menu_item'] = 'ficha'
kwargs['form'] = self.form
kwargs['oper'] = price_data_operation
kwargs['images'] = ImageFile.all().filter(
'property =', db.Key(key)).order('position')
return self.render_response('realestate/_ficha.html', **kwargs)
def post(self, **kwargs):
self.request.charset = 'utf-8'
user = get_or_404(self.get_user_key())
u_validated = self.form.validate()
if not u_validated:
kwargs['form'] = self.form
if self.form.errors:
kwargs['flash'] = self.build_error(
'Verifique los datos ingresados:')
return self.render(user, **kwargs)
user = self.form.update_object(user)
user.save()
# Actualizo los cambios en la sesión.
self.do_login(user)
self.set_ok('Usuario guardado satisfactoriamente.')
return self.redirect_to('backend/user/edit')
def post(self, **kwargs):
self.request.charset = 'utf-8'
realestate = kwargs['realestate']
# Ponemos la pantalla de disabled si esta en NO_PAYMENT
re = get_or_404(self.get_realestate_key_ex(realestate))
if re.status == RealEstate._NO_PAYMENT or re.plan.allow_website == 0:
return self.render_response('realestate/disabled.html',
realestate=re)
if not self.form.validate():
kwargs['flash'] = self.build_error(
'Verifique los datos ingresados:' + '<br/>'.join(
reduce(lambda x, y: str(x) + ' ' + str(y), t)
for t in self.form.errors.values()))
return self.get(**kwargs)
context = {
'realestate_key': realestate,
'sender_telephone': self.form.telephone.data,
'sender_name': self.form.name.data,
'sender_email': self.form.email.data,
'sender_comment': self.form.message.data,
'template_realestate': 1
}
def txn():
taskqueue.add(url=self.url_for('backend/email_task'),
params=dict({'action': 'contact_user'}, **context),
transactional=True)
taskqueue.add(url=self.url_for('backend/email_task'),
params=dict({'action': 'contact_agent'}, **context),
transactional=True)
db.run_in_transaction(txn)
self.set_ok(
'Tu consulta enviada satisfactoriamente. Te hemos enviado una copia de la consulta a tu correo.'
)
return self.redirect_to('realestate/info', realestate=realestate)
def get(self, **kwargs):
key = kwargs['key']
price_data_operation = kwargs['oper']
property = get_or_404(key)
property.visits = property.visits + 1
property.save(build_index=False)
price = property.price_sell
cur = property.price_sell_currency
if int(price_data_operation) == Property._OPER_RENT:
price = property.price_rent
cur = property.price_rent_currency
context = {
'property': property,
'Property': Property,
'price': price,
'cur': cur,
'config_array': config_array,
'price_data_operation': price_data_operation
}
context_ex = dict({'form': self.form}, **context)
context_ex = dict(
{
'images':
ImageFile.all().filter('property =',
db.Key(key)).order('position')
}, **context_ex)
ficha = self.render_template('frontend/templates/_ficha.html',
**context_ex)
tab = self.render_template('frontend/templates/_prop_tab.html',
**context)
return self.render_json_response({'ficha': ficha, 'tab': tab})
def tweet_index(cid):
"returns the edges that make up the crowd"
index = get_or_404(CrowdTweets,cid)
return index.to_d()
def id(tid):
"returns a tweet for the given id, or raises 404"
return get_or_404(Tweet,int(tid)).to_d()
def get(self, name):
author = get_or_404(Author, name=name)
session.delete(author)
session.commit()
return redirect(url_for('index'))
def get(self, title):
form = EditBookForm()
book = get_or_404(Book, title=title)
form.title.data = book.title
form.name.data = get_authors(book, format='str')
return render_template('edit_book.haml', form=form, title=title)
def get(self, name):
form = EditAuthorForm()
author = get_or_404(Author, name=name)
form.name.data = author.name
form.title.data = get_books(author, format ='str')
return render_template('edit_author.haml', form = form, name=name)
def id(cid):
"""returns all the information about a crowd in a dict"""
return get_or_404(Crowd,cid).to_d()
def edges(uid):
"""returns the first 5000 friends and follewers for the given user id, or
raises 404"""
return get_or_404(Edges,int(uid)).to_d()
def snapshot(date):
graph = get_or_404(CrowdSnapshot, parse_date(date))
return graph.to_d()
def simple(cid):
"""returns a crowd, after removing information about when users leave
and join plus when crowds split and merge"""
return get_or_404(Crowd,cid).simple()
def details(id):
cd = utils.get_or_404(Countdown, id)
return flask.render_template('details.html', countdown=cd)
def users(cid):
"returns all the users in a crowd"
crowd = get_or_404(Crowd,cid)
uids = [u['id'] for u in crowd.users]
users = User.find(User._id.is_in(uids))
return [u.to_d() for u in users]
def tweets(cid, page=0):
"returns all the tweets in a crowd"
index = get_or_404(CrowdTweets,cid)
tweets = index.tweets(int(page))
return [t.to_d() for t in tweets]
def create_success(id):
cd = utils.get_or_404(Countdown, id)
return flask.render_template('create_success.html', countdown=cd)
def id(uid):
"returns a user profile for the given id, or raises 404"
return get_or_404(User,int(uid)).to_d()
def get(self, title):
book = get_or_404(Book, title=title)
session.delete(book)
session.commit()
return redirect(url_for('index'))
def sizes(date):
sizes = get_or_404(CrowdSizes, parse_date(date))
return sizes.to_d()
