def render_maybeEdit(self, ctx, _):
"""Render action buttons if available."""
# pylint: disable-msg=E1101
if manages_list(ctx, must_user(ctx), self.list):
srv = IService(ctx)
if srv.isReserved(self.item):
notify = T.p[T.input(
type="checkbox", name="notify", value="1", checked=""),
u"\xa0Avertir la personne qui l'a réservé"]
else:
notify = []
return ctx.tag(_class="editable bl")[T.div(_class="br")[T.div(
_class="tl")[T.div(_class="tr")[T.form(
name='confirm',
action=url.here.child('confirm'),
method='POST',
_class="edcontent")[
notify,
T.input(type='submit',
name='confirm',
value=u"Confirmer l'effacement"),
T.input(type='submit', name='cancel', value=u"Annuler"
), ]]]]]
else:
return ''
def render_myLists(self, ctx, data):
"""Render the 'sender' field."""
selected = {}
for l in data['lst']:
selected[l.id] = True
# pylint: disable-msg=E1101
srv = IService(ctx)
user = must_user(ctx).user
lsts = srv.getListsOwnedBy(user)
lsts += srv.getFriendLists(user)
checkbox = []
for lst, _ in lsts:
name = lst.name or T.i[u'Liste sans nom']
args = {'type': "checkbox", 'name': "lst", 'value': lst.id}
if lst.id in selected:
args['checked'] = '1'
checkbox.append(
T.div(style="margin-left:2em")[T.input(**args)[u'\xa0' +
name]])
return ctx.tag[checkbox]
def renderHTTP(self, ctx):
"""Handle HTTP requests."""
srv = IService(ctx)
request = IRequest(ctx)
current = must_user(ctx)
user = srv.validate_challenge( # pylint: disable-msg=E1101
self.challenge, current.session)
if user:
message(ctx, u'Bienvenue, %s' % (user.email, ))
request.redirect("/")
request.finish()
return ''
# Some people simply reuse invitations: don't complain if they
# are already connected, just redirect them to the main page.
avatar = maybe_user(ctx)
if avatar.identified:
request.redirect("/")
request.finish()
return ''
# pylint: disable-msg=E1101
self.contentTags = [
T.h1[u"Cette clé n'est pas valable"],
T.p[u"Vous pouvez obtenir une nouvelle clé par e-mail.",
T.div(_class="editable bl")[T.div(_class="br")[T.div(
_class="tl")[T.div(_class="tr")[T.div(
_class="edcontent")[login.LoginFragment(
original=login.LoginInfo(
force_reconnect=True))], ]]]]]
]
return BasePage.renderHTTP(self, ctx)
def child_edit(self, ctx):
"""Handle edit requests."""
if not manages_list(ctx, must_user(ctx), self.list):
message(ctx, u"Vous n'avez pas le droit de modifier cet objet.")
return url.URL.fromContext(ctx).up()
if ctx.arg('cancel'):
message(ctx, u'La modification a été annulée.')
return url.URL.fromContext(ctx).up()
args = process_default(ctx, self.defaultValues)
if not (args['title'] or args['description'] or args['url']
or args['score']):
return url.URL.fromContext(ctx)
try:
score = int(args['score'])
if score > 3 or score < 1:
raise ValueError
except ValueError:
score = 2
srv = IService(ctx)
srv.editItem(
self.item, # pylint: disable-msg=E1101
args['title'],
args['description'],
args['url'],
score)
message(ctx, u'Votre souhait a bien été modifié.')
return url.URL.fromContext(ctx).up()
def child_confirm(self, ctx):
"""Confirm that an item has been donated."""
srv = IService(ctx)
avatar = must_user(ctx)
if not avatar.identified:
message(ctx, u"Vous devez confirmer votre email d'abord.")
return url.URL.fromContext(ctx).up().up()
srv.donatedItem(avatar.user, self.item) # pylint: disable-msg=E1101
message(ctx, u"Votre modification est enregistrée.")
return url.URL.fromContext(ctx).up().up()
def child_confirm(self, ctx):
"""Handle the confirmation that a list is dropped."""
srv = IService(ctx)
avatar = must_user(ctx)
srv.remove_from_friend( # pylint: disable-msg=E1101
avatar.user, self.list)
message(ctx, u'Vous ne suivez plus cette liste.')
return url.URL.fromString("/")
def child_giveup(self, ctx):
"""Handle reservation cancellation requests."""
srv = IService(ctx)
user = must_user(ctx).user
if ctx.arg('giveup'):
srv.giveupItem(user, self.item) # pylint: disable-msg=E1101
message(ctx, u"Votre modification est enregistrée.")
request = IRequest(ctx)
referer = request.getHeader('referer')
if referer:
return url.URL.fromString(referer)
return url.URL.fromContext(ctx).up()
def render_login(self, ctx, data):
"""Render the whole login box."""
# pylint: disable-msg=E1101
if IRequest(ctx).method == 'POST' and data.is_valid():
# Simply send a challenge to this email address
message(
ctx, u"""Un message de confirmation a été envoyé """
u"""à l'adresse <%s>.""" % data.email)
IService(ctx).pretend_email_address(
must_user(ctx).user, data.email)
IRequest(ctx).redirect(data.referer)
IRequest(ctx).finish()
else:
return ctx.tag
def child_confirm(self, ctx):
"""Handle .../confirm."""
if not manages_list(ctx, must_user(ctx), self.list):
message(ctx, u"Vous n'avez pas le droit de modifier cet objet.")
return url.URL.fromContext(ctx).up().up()
if ctx.arg('cancel'):
message(ctx, u"L'effacement a été annulé.")
return url.URL.fromContext(ctx).up().up()
srv = IService(ctx)
# pylint: disable-msg=E1101
srv.deleteItem(self.item, ctx.arg('notify'))
message(ctx, u'Votre souhait a bien été supprimé.')
return url.URL.fromContext(ctx).up().up()
def child_confirm(self, ctx):
"""Confirm that the list must be destroyed."""
if not owns_list(must_user(ctx), self.list):
return url.URL.fromContext(ctx).up()
if ctx.arg('cancel'):
message(ctx, u"L'opération a été annulée.")
return url.URL.fromContext(ctx).up()
srv = IService(ctx)
srv.destroyList(self.list) # pylint: disable-msg=E1101
message(ctx, u'Votre liste a bien été détruite.')
return url.URL.fromString("/")
def render_maybeEdit(self, ctx, _):
"""Render the edit buttons if the item can be edited."""
if manages_list(ctx, must_user(ctx), self.list):
# pylint: disable-msg=E1101
def _make_option(value, comment):
"""Build on choice of a score."""
if value == self.item.score:
checked = 'yes'
else:
checked = None
return T.li[T.input(
type="radio",
name="score",
value=str(value),
checked=checked)[T.span(
style="padding-right:1ex")[self._make_score(value)],
comment]],
scores = T.ul[_make_option(1, u'Pourquoi pas...'),
_make_option(2, u'Chouette\xa0!'),
_make_option(3, u'Oh oui, Oh oui\xa0!')]
return ctx.tag(_class="editable", render=self.render_rounded_box)[
T.form(name='edit',
action=url.here.child('edit'),
method='POST')
[T.input(type='text',
name='title',
_class='inputfield',
value=self.item.title or self.defaultValues['title']),
T.br,
T.textarea(name='description', _class='inputfield', rows='5'
)[self.item.description
or self.defaultValues['description']], T.br,
T.input(type='text',
name='url',
_class='inputfield',
value=self.item.url or self.defaultValues['url']),
scores,
T.input(type='submit',
name='edit',
value=u'Enregistrer les modifications'),
T.input(type='submit', name='cancel', value=u'Annuler'), ]]
else:
return ''
def _create_list(self, ctx, name, email):
"""Actually create the new list."""
req = IRequest(ctx)
srv = IService(ctx)
avatar = must_user(ctx)
# pylint: disable-msg=E1101
wl = srv.createList(avatar.user, name, email)
if not wl:
req.redirect('/')
req.finish()
return
if not avatar.identified:
message(
ctx, u"Un message de confirmation a été envoyé"
u" à l'adresse <%s>." % (email, ))
req.redirect('/' + wl.url)
req.finish()
def child_get(self, ctx):
"""Handle reservation requests."""
avatar = must_user(ctx)
if owns_list(avatar, self.list):
message(ctx, u"Vous ne pouvez pas réserver un de vos souhaits.")
return url.URL.fromContext(ctx).up()
# In any case, the item is reserved. It is up to the user to
# possibly confirm his identity.
if not avatar.anonymous:
srv = IService(ctx)
# pylint: disable-msg=E1101
srv.reserveItem(avatar.user, self.item)
message(ctx, u'Votre réservation est enregistrée.')
return url.URL.fromContext(ctx).up()
message(
ctx, u'Votre réservation sera effective lorsque '
u'vous vous serez identifié.')
# redirect here after authentication
referer = url.URL.fromContext(ctx).child('get')
return url.URL.fromString('/login').add(name='referer', value=referer)
def child_add(self, ctx):
"""Handle the .../add page."""
avatar = must_user(ctx)
if not manages_list(ctx, avatar, self.list):
log.msg('unauthorized access to the list/add method')
return url.URL.fromContext(ctx)
args = {}
for k in self.defaultValues.keys():
v = ctx.arg(k) or ''
v = v.strip().decode('utf-8')
if not v or \
v == self.defaultValues[k]:
args[k] = ''
else:
args[k] = v
if not (args['title'] or args['description'] or args['url']):
return url.URL.fromContext(ctx)
srv = IService(ctx)
srv.addNewItem(
self.list,
args['title'], # pylint: disable-msg=E1101
args['description'],
args['url'])
message(ctx, u'Votre souhait a bien été enregistré.')
back = ctx.arg('back')
if back:
back = url.URL.fromString(back)
else:
back = url.URL.fromContext(ctx)
return back
def data_form(self, ctx, _):
"""Return the options passed in the invitation form."""
req = IRequest(ctx)
warn = []
vals = {'msg': ''}
srv = IService(ctx)
avatar = must_user(ctx)
user = avatar.user
# pylint: disable-msg=E1101
if req.method == 'POST':
if not arg(req, 'send'):
req.redirect('/')
req.finish()
return self._defaults
if not avatar.identified:
warn.append(u"Vous n'avez pas encore activé votre compte.")
vals['sender'] = arg(req, 'sender')
if not vals['sender']:
warn.append(u"Vous n'avez pas précisé votre nom.")
vals['email'] = arg(req, 'email')
if not vals['email']:
warn.append(u"Vous n'avez pas précisé de destinataire.")
vals['body'] = arg(req, 'body')
if not vals['body']:
warn.append(u"Votre message n'a pas de contenu.")
# We simply filter out lists that don't belong to the
# user.
vals['lst'] = _my_lists(req.args.get('lst', []), srv, user)
if not vals['lst']:
warn.append(u"Choisissez au moins une liste ci-dessous.")
vals['warn'] = warn
if not warn:
if not srv.inviteFriend(vals['sender'], user, vals['lst'],
vals['email'], vals['body']):
warn.append(u"L'adresse <%s> n'est pas valide." %
(vals['email'], ))
else:
vals['msg'] = u'Votre invitation a été envoyée à %s' % (
vals['email'], )
# When we have sent properly, forget the previous
# emails, so we don't double-send by mistake.
vals['email'] = ''
else:
vals = self._defaults
vals['lst'] = _my_lists(req.args.get('lst', []), srv, user)
return vals
def child_change(self, ctx):
"""Handle modification requests."""
if not manages_list(ctx, must_user(ctx), self.list):
message(ctx, u"Vous n'avez pas le droit de modifier cet objet.")
return url.URL.fromContext(ctx).up()
if ctx.arg('cancel'):
message(ctx, u'Les modifications ont été annulées.')
return url.URL.fromContext(ctx).up()
args = process_default(ctx, self.defaultValues)
success = True
updates = {'description': args['listDesc']}
if not args['listTitle']:
message(ctx, u'Il faut donner un titre à la liste.')
success = False
else:
updates['title'] = args['listTitle']
proposed = args['listUrl']
if not proposed:
message(ctx, u'Il faut donner une URL à la liste.')
success = False
else:
# We only update the url if it actually changed !
if proposed != self.list.url:
updates['url'] = proposed
else:
proposed = None
if args['showRes']:
updates['showres'] = 1
else:
updates['showres'] = 0
if (args['theme'] in theme.themes
and self.theme().key != args['theme']):
updates['theme_id'] = args['theme']
srv = IService(ctx)
# pylint: disable-msg=E1101
current_coeds = srv.getCoEditors(self.list)
# coEditors
coeds = args['coEditors'].strip()
if coeds:
new_coeds = [x.strip() for x in self._coedsplit.split(coeds)]
if new_coeds != current_coeds:
updates['coEditors'] = new_coeds
# pylint: disable-msg=E1101
new, unknown = srv.updateList(self.list, **updates) or self.list.url
if unknown:
missed = u', '.join(unknown)
message(
ctx,
u"Les personnes suivantes ne sont pas connues\xa0: " + missed)
return url.URL.fromString('/').child(new).child('edit')
if proposed and new != proposed:
# We could not get the proposed URL, simply warn the user
# pylint: disable-msg=E1101
message(
ctx, T.div[u"L'URL ",
T.tt['<http://mes-souhaits.net/' + proposed + '>'],
" étant indisponible, ",
T.tt['<http://mes-souhaits.net/' + new + '>'],
" a été utilisée à la place."])
if success:
message(ctx, u'Les modifications ont été effectuées.')
return url.URL.fromString('/').child(new)
return url.URL.fromString('/').child(new).child('edit')
