def save_listes(self):
""" save mailing lists
"""
user = self.user_id
admin = self.admin
uid = request.POST.get('uid')
if admin and uid:
user = ldap.getUser(uid)
else:
user = self.user
email = user.email
new_selected = request.POST.getall('selected')
selected = mailman.lists.getListsFor(email)
for ml in mailman.lists.values():
if ml.name in new_selected:
if ml.name not in selected:
if ml.name == 'afpy-membres' and user.expired:
continue
elif not self.admin and not ml.public:
continue
else:
ml.append(email)
elif ml.name in selected:
del ml[email]
return self.listes(id=user.uid,
errors=[form_message(u'Modification sauvegardées')])
def change_password(self):
uid = request.POST.get('uid')
mail = request.POST.get('mail')
user = None
errors = []
passwd = ''.join(random.sample(string.ascii_letters, 6))
if uid:
user = ldap.getUser(uid)
if not user:
errors.append('Impossible de trouver votre login')
if not user and mail:
conn = ldap.get_conn()
members = conn.search_nodes(node_class=ldap.User,
filter='(mail=%s)' % mail)
if len(members) == 1:
user = members[0]
else:
errors.append('Impossible de trouver votre courriel')
if user:
user.change_password(passwd)
mail = LDAPMailTemplate(name='send_password',
subject='Votre mot de passe sur afpy.org',
passwd=passwd,
mfrom='*****@*****.**')
mail.send(user.uid)
return u"""Votre mot de passe à été modifié. Vous allez recevoir un
courriel de confirmation."""
errors.insert(0, 'Impossible de vous identifier')
return self.password_form(uid=uid, mail=mail, errors=errors)
def send(self, uid, **kwargs):
if isinstance(uid, ldap.User):
user = uid
else:
user = ldap.getUser(uid)
data = dict(user=user)
data.update(self.data)
data.update(kwargs)
mto = [kwargs.get('mto', user.email)]
if 'cc' in data:
cc = data['cc'].split(',')
cc = [c.strip() for c in cc]
mto = mto + cc
dirname = os.path.abspath(os.path.dirname(__file__))
path = os.path.join(dirname, 'templates', '%s.txt' % self.name)
if not os.path.isfile(path):
path = os.path.join(dirname, 'templates', '%s.rst' % self.name)
mail = MakoMail(path=path,
format='plain',
mto=', '.join(mto),
mfrom=self.mfrom,
afpy_org='http://www.afpy.org',
**data)
if self.server is None:
self.server = smtplib.SMTP(self.host, self.port)
self.server.sendmail(self.mfrom, ','.join(mto), str(mail))
def test_fieldset():
from afpy.ldap import custom as ldap
user = ldap.getUser('gawel')
fs = FieldSet(ldap.User)
fs = fs.bind(user)
# rendering
assert fs.uid.is_required() == True, fs.uid.is_required()
assert fs.uid.value == 'gawel'
html = fs.render()
assert 'class="field_req" for="User-gawel-uid"' in html, html
assert 'value="gawel"' in html, html
# syncing
fs.configure(include=[fs.uid])
fs.rebind(user, data={'User-gawel-uid': 'minou'})
fs.validate()
fs.sync()
assert fs.uid.value == 'minou', fs.render_fields
assert user.uid == 'minou', user.uid
# grid
fs = Grid(ldap.User, [user, ldap.User()])
html = fs.render()
assert '<thead>' in html, html
assert 'value="minou"' in html, html
def manage_ZopeUser(action, name, passwd='', manager=0, user=None):
""" @action: add | edit | delete
"""
try:
request.path_info
except TypeError:
pass
else:
if 'paste.testing' in request.environ:
return True
if not user:
user = ldap.getUser(name)
elif password:
user.change_password(passwd)
groups = user.groups
if 'cd' in groups or 'bureau' in groups:
manager = 1
try:
server = xmlrpclib.Server('%s/ldap/' % config.zope_admin_url())
return server.manage_User(action, user.cn or user.uid, passwd, manager)
except xmlrpclib.Fault:
pass
except socket.error:
pass
def relance_payments():
parser = OptionParser()
parser.add_option("-s", "--smtp", dest="host",
default=None,
help="smtp server to use")
(options, args) = parser.parse_args()
mail = LDAPMailTemplate('need_payment',
cc='*****@*****.**',
subject="[Relance AFPy] Votre cotisation à l'association est expirée",
signature='tresorier')
if options.host:
mail.host = options.host
members = ldap.getAwaitingPayments() | ldap.getExpiredUsers()
for uid in members:
u = ldap.getUser(uid)
try:
ldap.updateExpirationDate(u)
except:
print 'Cant edit %s' % u
else:
if u.expired:
print 'Sending mail to', u.uid, u.email, 'expired since:', u.membershipExpirationDate
mail.send(u)
vips = set(ldap.getMembersOf('bureau')) | set(ldap.getMembersOf('cd'))
for uid in vips:
if uid in members:
continue
u = ldap.getUser(uid)
try:
ldap.updateExpirationDate(u)
except:
print 'Cant edit %s' % u
else:
if u.expired or not u.payments:
print 'Sending mail to', u.uid, u.email, 'expired since:', u.membershipExpirationDate
mail.send(u)
print len(vips|members), 'relances sent'
def setUp(self):
user = ldap.User('afpy_test_user',
attrs=dict(cn='Test User', sn='Test'),
conn=conn)
try:
conn.add(user)
except:
log.warn('afpy_test_user already exist')
user = ldap.getUser('afpy_test_user')
user.change_password('toto')
self.user = user
self.setUpApp()
def listes(self, id='', errors=''):
user = id and ldap.getUser(id) or self.user
admin = self.admin
html = ''
if user != self.user and not admin:
raise NotAuthorizedError()
if admin and self.user != user:
element = 'listes_%s' % user
hidden = h.hidden('uid', user.uid)
else:
element = 'contents'
hidden = ''
html += tag('legend', 'Listes de diffusion')
html += display_errors(errors)
html += h.form(url=h.url.current(action='save_listes', id=None),
class_='remote', onsubmit="return remote_form(this);",
alt=element)
html += hidden
email = user.email
selected = mailman.lists.getListsFor(email)
for ml in mailman.lists.values():
# hide private list if not subbcribed
if ml.name == 'afpy-membres' and \
getattr(user, 'membershipExpirationDate', None):
pass
elif not admin and not ml.public and ml.name not in selected:
continue
html += h.literal('<div>')
html += h.checkbox('selected',
id=ml.name,
checked=ml.name in selected,
value=ml.name)
html += h.literal(' ')
html += tag('label', ml.title, **{'for': ml.name})
html += h.literal(' (')
html += h.link_to(
'infos',
'http://lists.afpy.org/mailman/listinfo/%s' % ml.name)
html += h.literal(')')
html += h.literal('</div>')
html += tag('div', h.literal(' '))
html += h.submit('save', 'Sauver', **{'class': 'context'})
html += h.end_form()
return tag('fieldset', html)
def test_subscribe_cheque(self):
resp = self.app.post(url(controller='my', action='subscribe'),
dict(paymentComment='my comment cheque',
paymentObject=ldap.PERSONNAL_MEMBERSHIP,
paymentDate='20000101000000Z',
paymentMode='cheque'),
extra_environ=admin_environ)
resp.mustcontain("vous devez maintenant nous faire parvenir", "Tresorier de l'association")
mail = self.mail_output()
mail.mustcontain("- Mode de paiement: cheque", 'my comment')
u = ldap.getUser('gawel')
assert 'cheque' in u.payments[0].invoiceReference
def test_subscribe_paypal(self):
resp = self.app.post(url(controller='my', action='subscribe'),
dict(paymentComment='my comment paypal',
paymentObject=ldap.PERSONNAL_MEMBERSHIP,
paymentDate='20000101000000Z',
paymentMode='paypal'),
extra_environ=admin_environ)
resp.mustcontain('https://www.paypal.com/fr/cgi-bin/webscr')
mail = self.mail_output()
mail.mustcontain("- Mode de paiement: paypal")
u = ldap.getUser('gawel')
assert 'paypal' in u.payments[0].invoiceReference
def test_subscribe_payed(self):
resp = self.app.post(url(controller='my', action='subscribe'),
dict(paymentComment='my comment payed',
paymentObject=ldap.PERSONNAL_MEMBERSHIP,
paymentDate='20000101000000Z',
paymentMode='payed'),
extra_environ=admin_environ)
resp.mustcontain("Un courriel vous a")
mail = self.mail_output()
mail.mustcontain("- Mode de paiement: payed", 'my comment')
u = ldap.getUser('gawel')
assert 'payed' in u.payments[0].invoiceReference
def info(self, id=None):
""" user form """
admin = self.admin
if admin and id:
user = ldap.getUser(id)
else:
user = self.user
if user != self.user and not admin:
raise NotAuthorizedError()
html = title = ''
if admin:
fs_klass = AdminUserForm
fs = AdminUserForm
else:
fs_klass = UserForm
fs = fs_klass.bind(user, data=request.POST or None)
if request.POST and fs.validate():
fs.sync()
user.save()
fs = fs_klass.bind(user, data=None)
message = form_message(u'Modifie').encode('utf-8')
e = ValidationError(message)
fs._errors = [e]
html += fs.render()
if admin and id:
element = 'infos_%s' % user.uid
url = h.url(controller='my', action='info', id=id)
else:
element = 'contents'
url = h.url(controller='my', action='info')
form = h.form(url=url, class_="remote",
onsubmit="return remote_form(this);", alt=element)
html = title + tag(
'fieldset',
h.literal(tag('legend', u'Mes informations')) +
h.literal(form) + h.literal(tag('table', h.literal(html))) +
h.submit("save", "Sauver", class_='context') +
h.literal('</form>'))
return html
def validate_uid(value, field):
try:
value = str(value)
except UnicodeEncodeError:
raise validators.ValidationError(
"Le login ne doit contenir que de l'ASCII")
for v in value:
if v not in string.ascii_letters + '-_204':
raise validators.ValidationError(
"Le login ne doit contenir que de l'ASCII")
if ' ' in value:
raise validators.ValidationError(
"Le login ne doit pas contenir d'espace")
if len(value) < 4:
raise validators.ValidationError(
"Le login doit contenir au moins 4 characteres")
if ldap.getUser(value):
raise validators.ValidationError('Cet identifiant est pris')
return value
def test_index(self):
response = self.app.post(
url(controller='register', action='register_form'))
form = response.forms[0]
form['User--uid'] = 'gawel'
form['User--mail'] = '*****@*****.**'
form['User--password'] = '******'
response = form.submit('validate')
response.mustcontain('Cet identifiant est pris')
form['User--uid'] = 'afpy_test_user'
form['User--mail'] = '*****@*****.**'
form['User--password'] = '******'
response = form.submit('validate')
response.mustcontain('Cet email est pris')
form['User--uid'] = 'afpy_test_user'
form['User--mail'] = '*****@*****.**'
form['User--password'] = '******'
response = form.submit('validate')
response.mustcontain('Cet email est pris')
form['User--uid'] = 'Afpy_Test_User'
form['User--sn'] = 'Afpy User'
form['User--mail'] = '*****@*****.**'
form['User--password'] = '******'
response = form.submit('validate')
response.mustcontain('Votre inscription', 'Vous allez recevoir')
user = ldap.getUser('afpy_test_user')
assert user is not None
mail = self.mail_output()
mail.mustcontain('afpy_test_user', user.street[0:6])
response = self.app.get(
url(controller='register',
action='confirm',
uid=user.uid,
key=user.street))
assert 'Votre+inscription+est+maintenant' in response.location, response
def tearDown(self):
TestController.tearDown(self)
u = ldap.getUser('gawel')
p = u.payments[0]
if p.get('paymentDate') == '20000101000000Z':
p.conn.delete(p)
def tearDown(self):
user = ldap.getUser('afpy_test_user')
if user is not None:
user.conn.delete(user)
from routes.util import URLGenerator
from webtest import TestApp
from afpy.ldap import custom as ldap
from iw.email.testing import EmailTestCase
import pylons.test
__all__ = ['environ', 'url', 'TestController', 'admin_environ']
# Invoke websetup with the current config file
SetupCommand('setup-app').run([config['__file__']])
environ = {}
admin_environ = {
'REMOTE_USER': '******',
'repoze.who.identity': dict(user=ldap.getUser('gawel'), userid='gawel'),
'repoze.what.credentials': dict(
groups=("bureau", ),
permissions=[],
),
}
class TestController(EmailTestCase):
def __init__(self, *args, **kwargs):
if pylons.test.pylonsapp:
wsgiapp = pylons.test.pylonsapp
else:
wsgiapp = loadapp('config:%s' % config['__file__'])
self.app = TestApp(wsgiapp)
url._push_object(URLGenerator(config['routes.map'], environ))
