def make_form(self, html_class="settings_form"):
"""
Create the FORM, and the DIVs with the input fields
"""
if config.use_ssl:
action = self.request.getScriptname() + self.request.getPathinfo()
if config.wiki_farm:
action = "%s%s" % (farm.getBaseFarmURL(
self.request, force_ssl=config.use_ssl),
wikiutil.quoteWikiname(
config.page_user_preferences))
else:
action = '%s/%s' % (self.request.getQualifiedURL(
self.request.getScriptname(),
force_ssl=config.use_ssl),
wikiutil.quoteWikiname(
config.page_user_preferences))
else:
action = self.request.getScriptname() + self.request.getPathinfo()
self._form = html.FORM(action=action)
self._inner = html.DIV(html_class=html_class)
# Use the user interface language and direction
lang_attr = self.request.theme.ui_lang_attr()
self._form.append(html.Raw("<div %s>" % lang_attr))
self._form.append(html.INPUT(type="hidden", name="action",
value="userform"))
if self.from_wiki:
self._form.append(html.INPUT(type="hidden", name="from_wiki",
value=self.from_wiki))
self._form.append(self._inner)
self._form.append(html.Raw("</div>"))
def send_validation_email(wikiname, request):
if not config.mail_smarthost:
msg = ("This wiki is not enabled for mail processing. "
"Contact the owner of the wiki, who can enable email.")
elif not request.isPOST():
msg = "Use the interactive interface to change settings!"
# check whether the user has an email address
elif not request.user.email:
msg = ("You didn't enter an email address in your profile. "
"Select settings in the upper right corner and enter a "
"valid email address.")
else:
code = _createCode(request)
text = ("To create your wiki, %s, follow go to this URL: "
"%s?action=new_wiki&wikiname=%s&code=%s . "
"Note that this magic wiki-creating URL will expire in "
"30 minutes." % (wikiname, farm.getBaseFarmURL(request),
wikiname, code))
mailok, msg = mail.sendmail(request, [request.user.email],
"Creating your wiki..", text,
mail_from=config.mail_from)
msg = ("An email with instructions has been sent to your email "
"address, %s. Check your mail!" % request.user.email)
return msg
def html_head(self, d):
"""
Assemble html head
@param d: parameter dictionary
@rtype: string
@return: html head
"""
dict = {
'stylesheets_html': self.html_stylesheets(d),
}
dict.update(d)
dict['theme_last_modified'] = self.last_modified
dict['newtitle'] = None
dict['newtitle'] = dict['title']
if dict['title'] == 'Front Page':
dict['newtitle'] = wikiutil.escape(self.request.config.catchphrase)
dict['web_dir'] = config.web_dir
if d['page'].hasMapPoints():
dict['wiki_name'] = self.request.config.wiki_name
if config.wiki_farm:
dict['map_base'] = farm.getBaseFarmURL(self.request)
else:
dict['map_base'] = self.request.getBaseURL()
dict['gmaps_api_key'] = (self.request.config.gmaps_api_key or
config.gmaps_api_key)
dict['map_html'] = (
'<script type="text/javascript">'
'var gmaps_src="http://maps.google.com/maps?file=api&v=2&'
'key=%(gmaps_api_key)s";'
'</script>'
'<script src="%(web_dir)s/wiki/gmap.js?tm=%(theme_last_modified)s" '
'type="text/javascript">'
'</script>'
'<script type="text/javascript">'
'var map_url="%(map_base)s?action=gmaps&wiki=%(wiki_name)s";'
'var point_count=1;</script>' % dict)
else:
dict['map_html'] = ''
if dict['newtitle'] is self.request.config.catchphrase:
if self.request.config.catchphrase:
html = ('<title>%(sitename)s - %(newtitle)s</title>\n'
'%(map_html)s\n'
'%(stylesheets_html)s\n' % dict)
else:
html = ('<title>%(sitename)s</title>\n'
'%(map_html)s\n'
'%(stylesheets_html)s\n' % dict)
else:
html = ('<title>%(newtitle)s - %(sitename)s</title>'
'%(map_html)s\n'
'%(stylesheets_html)s\n' % dict)
return html
def execute(macro, args, formatter=None):
request = macro.request
before_form, after_form = '', ''
if args and len(args.split(',')) == 2:
before_form, after_form = args.split(',')
if not formatter:
formatter = macro.formatter
if not config.allow_web_based_wiki_creation:
return ('<i>This wiki farm does not have web-based wiki creation '
'enabled.</i>')
if request.user.valid:
d = {'form_action': formatter.page.url(),
'wikiname_length': farm.WIKINAME_MAX_LENGTH,
'create_wiki_button': 'send_email',
'after_form': after_form,
'before_form': before_form,
}
wiki_create_form = (
'<form action="%(form_action)s" method="POST">\n'
'<span class="wikiNameArea">'
'<input type="hidden" name="action" value="new_wiki">\n'
'%(before_form)s'
'<input type="text" class="wikiname" name="wikiname" '
'size="15" value="shortname" '
'maxlength="%(wikiname_length)s" '
'onFocus="this.value=\'\';this.style.color=\'black\';return false;">\n'
'<input type="hidden" name="%(create_wiki_button)s" '
'value="1">\n'
'<span class="description">%(after_form)s</span>'
'</span>'
'<span class="submit"><input type="submit" value="Create wiki"></span>\n'
'</form>\n' % d)
else:
new_user_link = ('%s%s?new_user=1' %
(farm.getBaseFarmURL(request),
wikiutil.quoteWikiname(
config.page_user_preferences)))
wiki_create_form = ('You must be logged in to create a wiki! '
'To create an account, go '
'<a href="%s">here</a>.' % new_user_link)
return formatter.rawHTML('<span id="wikiCreateForm">%s</span>' %
wiki_create_form)
def html_head(self, d):
"""
Assemble html head
@param d: parameter dictionary
@rtype: string
@return: html head
"""
dict = {
'stylesheets_html': self.html_stylesheets(d),
}
dict.update(d)
dict['theme_last_modified'] = self.last_modified
dict['newtitle'] = None
dict['newtitle'] = dict['title']
if dict['title'] == 'Front Page':
dict['newtitle'] = wikiutil.escape(self.request.config.catchphrase)
dict['web_dir'] = config.web_dir
if d['page'].hasMapPoints():
dict['wiki_name'] = self.request.config.wiki_name
if config.wiki_farm:
dict['map_base'] = farm.getBaseFarmURL(self.request)
else:
dict['map_base'] = self.request.getBaseURL()
dict['gmaps_api_key'] = (self.request.config.gmaps_api_key or
config.gmaps_api_key)
dict['map_html'] = (
'<script type="text/javascript">'
'var gmaps_src="http://maps.google.com/maps?file=api&v=2&'
'key=%(gmaps_api_key)s";'
'</script>'
'<script src="%(web_dir)s/wiki/gmap.js?tm=%(theme_last_modified)s" '
'type="text/javascript">'
'</script>'
'<script type="text/javascript">'
'var map_url="%(map_base)s?action=gmaps&wiki=%(wiki_name)s";'
'var point_count=1;</script>' % dict)
else:
dict['map_html'] = ''
dict['searchsuggest_html'] = ''
dict['searchsuggest_html'] += '<script type="text/javascript" src="/wiki/jquery.js"></script>'
dict['searchsuggest_html'] += '<script type="text/javascript" src="/wiki/jquery.qtip-1.0.0-rc3.min.js"></script>'
if config.opensearch_suggest_url:
dict['searchsuggest_html'] += '<script type="text/javascript" src="/wiki/suggest/dimensions.js"></script>'
dict['searchsuggest_html'] += '<script type="text/javascript" src="/wiki/suggest/autocomplete.js"></script>'
dict['stylesheets_html'] += '<link rel="stylesheet" type="text/css" charset="iso-8859-1" media="all" href="/wiki/suggest/autocomplete.css">\n'
if dict['newtitle'] is self.request.config.catchphrase:
if self.request.config.catchphrase:
html = ('<title>%(sitename)s - %(newtitle)s</title>\n'
'%(map_html)s\n'
'%(stylesheets_html)s\n'
'%(searchsuggest_html)s\n' % dict)
else:
html = ('<title>%(sitename)s</title>\n'
'%(map_html)s\n'
'%(stylesheets_html)s\n'
'%(searchsuggest_html)s\n' % dict)
else:
html = ('<title>%(newtitle)s - %(sitename)s</title>'
'%(map_html)s\n'
'%(stylesheets_html)s\n'
'%(searchsuggest_html)s\n' % dict)
return html
def username(self, d):
"""
Assemble the username / userprefs link
@param d: parameter dictionary
@rtype: string
@return: username html
"""
_ = self.request.getText
if self.request.user.valid:
watch_wiki = ''
if config.wiki_farm:
if not self.request.user.isWatchingWiki(
self.request.config.wiki_name):
watch_wiki = ('| %s ' %
Page(d['page_name'],self.request).link_to(
know_status=True, know_status_exists=True,
text='watch this wiki',
querystr='action=watch_wiki&wikiname=%s' %
self.request.config.wiki_name))
if config.wiki_farm:
wiki_base_url = farm.getBaseFarmURL(self.request)
else:
wiki_base_url = '%s/' % self.request.getScriptname()
if self.request.user.name in wikiacl.Group("Admin", self.request):
wiki_settings_pagelink = \
Page(config.wiki_settings_page, self.request).link_to(
text=config.wiki_settings_page.lower())
admin_settings = ('%s | ' % wiki_settings_pagelink)
else:
admin_settings = ''
html = (
'<div class="user_area">'
'<div class="welcome">Welcome, %s</div>'
'%s'
'<div class="user_items">'
'(%s<a href="%s%s?from_wiki=%s">settings</a> %s| '
'<a href="%s/%s?action=userform&logout=Logout">logout</a>)'
'</div></div>' %
(user.getUserLink(self.request, self.request.user),
self.userNotificationLink(self.request.user),
admin_settings, wiki_base_url,
wikiutil.quoteWikiname(config.page_user_preferences),
self.request.config.wiki_name, watch_wiki,
self.request.getScriptname(), d['q_page_name']))
else:
if config.wiki_farm:
post_url = "%s%s" % (
farm.getBaseFarmURL(self.request,
force_ssl=config.use_ssl),
wikiutil.quoteWikiname(config.page_user_preferences))
our_wiki_url = '%s/%s' % (self.request.getBaseURL(),
d['q_page_name'])
base_wiki = farm.getBaseFarmURL(self.request)
farm_params = (
'<input type="hidden" name="backto_wiki" value="%s">'
'<input type="hidden" name="backto_page" value="%s">'
'<input type="hidden" name="qs" value="%s">' %
(self.request.config.wiki_name,
urllib.quote(our_wiki_url),
urllib.quote(self.request.query_string)))
else:
farm_params = ''
post_url = '%s/%s' % (
self.request.getQualifiedURL(self.request.getScriptname(),
force_ssl=config.use_ssl),
wikiutil.quoteWikiname(config.page_user_preferences))
base_wiki = '%s/' % self.request.getScriptname()
html = (
'<form action="%s" method="POST" '
'onsubmit="if (!canSetCookies()) { alert(\'You need '
'cookies enabled to log in.\'); '
'return false;}">'
'<input type="hidden" name="action" value="userform">'
'<div class="login_area">'
'<table>'
'<tr><td width="50%%" align="right" nowrap>User name:</td>'
'<td colspan="2" align="left" nowrap>'
'<input class="formfields" size="22" name="username" '
'type="text"></td> </tr> <tr>'
'<td align="right">Password:</td>'
'<td colspan="2" align="left" nowrap> '
'<input class="formfields" size="22" type="password" '
'name="password"> '
'<input type="hidden" name="login" value="Login">%s'
'</td></tr><tr><td></td>'
'<td align="left" nowrap>'
'(<a href="%s%s?new_user=1&from_wiki=%s">new user</a>)'
'</td><td align="right">'
'<input type="submit" name="login" value="Login" alt="login">'
'</td></tr></table></div></form>' %
(post_url, farm_params, base_wiki,
wikiutil.quoteWikiname(config.page_user_preferences),
self.request.config.wiki_name))
return html
def handleData(self, new_user=None):
from Sycamore.Page import MAX_PAGENAME_LENGTH as MAX_USERNAME_LENGTH
_ = self._
form = self.request.form
msg = ''
isdisabled = False
if form.get('disabled', [0])[0] == '1':
isdisabled = True
self.from_wiki = None
if self.request.form.has_key('from_wiki'):
self.from_wiki = self.request.form['from_wiki'][0].lower().strip()
if not wikiutil.isInFarm(self.from_wiki, self.request):
self.from_wiki = None
new_user = int(form.get('new_user', [0])[0])
# wiki farm authentication
# we want them to be able to sign back in right after they
# click the 'logout' GET link, hence this test
is_form_logout = (form.has_key('qs') and
urllib.unquote(form['qs'][0]) ==
'action=userform&logout=Logout')
if (self.request.form.has_key('badlogin') and
self.request.form['badlogin'][0]):
_create_nologin_cookie(self.request)
if config.wiki_farm:
wiki_base_url = farm.getBaseFarmURL(self.request)
else:
wiki_base_url = '%s/' % self.request.getScriptname()
return_string = ('Unknown username or wrong password.<br/><br/>'
'New user? <a href="%s%s?new_user=1">Click here '
'to create an account!</a><br/><br/>'
'Forgot your password? We\'ll email it to you.'
'<form action="%s" method="POST">'
'<input type="hidden" name="action" '
'value="userform">'
'Email address: <input class="formfields" '
'type="text" name="email">'
' <input type="submit" class="formbutton" '
'name="login_sendmail" '
'value="Mail me my account data">'
'</form>' % (
wiki_base_url,
wikiutil.quoteWikiname(
config.page_user_preferences),
wiki_base_url))
return return_string
if (form.has_key('login_check') and form['login_check'][0] and
form.has_key('backto_wiki') and form.has_key('backto_page')):
backto_wiki = form['backto_wiki'][0]
backto_page = form['backto_page'][0].encode(config.charset)
if form.has_key('qs') and not is_form_logout:
q_query_string = form['qs'][0]
else:
q_query_string = ''
if self.request.user.valid:
secret, stored_expire_time, session = \
self.request.user.cookie_dough
if q_query_string:
url = ('%s?action=userform&backto_page=%s&qs=%s'
'&secret=%s&expire_time=%s&uid=%s&session=%s' % (
backto_page, urllib.quote(backto_page),
urllib.quote(q_query_string), urllib.quote(secret),
stored_expire_time, self.request.user.id,
urllib.quote(session)))
else:
url = ('%s?action=userform&backto_page=%s&secret=%s'
'&expire_time=%s&uid=%s&session=%s' % (
backto_page, urllib.quote(backto_page),
urllib.quote(secret), stored_expire_time,
self.request.user.id, urllib.quote(session)))
else:
if q_query_string:
url = ('%s?action=userform&backto_page=%s¬_logged_in=1'
'&qs=%s' % (backto_page, urllib.quote(backto_page),
urllib.quote(q_query_string)))
else:
url = ('%s?action=userform&backto_page=%s¬_logged_in=1'
% (backto_page, urllib.quote(backto_page)))
self.request.http_redirect(url)
return
# bounce-back wiki farm authentication
if form.has_key('not_logged_in') and form.has_key('backto_page'):
backto = urllib.unquote(form['backto_page'][0].encode(
config.charset))
if form.has_key('qs') and not is_form_logout:
query_string = '?%s' % (urllib.unquote(form['qs'][0]
).encode(config.charset))
else:
query_string = ''
url = '%s%s' % (backto, query_string)
_create_nologin_cookie(self.request)
self.request.http_redirect(url)
return
# bounce-back wiki farm authentication
elif (form.has_key('uid') and form.has_key('secret') and
form.has_key('session') and form.has_key('expire_time')):
uid = form['uid'][0]
secret = urllib.unquote(form['secret'][0])
session = form['session'][0]
expire_time = float(form['expire_time'][0])
if form.has_key('backto_page'):
backto_page = form['backto_page'][0]
else:
backto_page = '/'
if form.has_key('qs') and not is_form_logout:
query_string = '?%s' % urllib.unquote(form['qs'][0])
else:
query_string = ''
url = '%s%s' % (backto_page, query_string)
self.request.http_redirect(url)
self.request.user.sendCookie(self.request, expire=expire_time,
sessionid=session, secret=secret,
id=uid)
self.request.user.clearNologinCookie(self.request)
return
if form.has_key('logout') or isdisabled:
msg = ''
if isdisabled:
if not self.request.isPOST():
return "Use the interactive interface to change settings!"
# disable the account
self.request.user.disabled = 1
# save user's profile
self.request.user.save()
msg = '<p>%s</p>' % _("Your account has been disabled.")
# clear the cookie in the browser and locally
try:
cookie = Cookie.SimpleCookie(self.request.saved_cookie)
except Cookie.CookieError:
# ignore invalid cookies
cookie = None
else:
if config.wiki_farm:
cookie_id = wikiutil.quoteCookiename(
config.wiki_base_domain + ',ID')
else:
cookie_id = wikiutil.quoteCookiename(
config.sitename + ',ID')
if cookie.has_key(cookie_id):
self.removeSession(cookie[cookie_id].value)
cookie_dir = config.web_dir
if not cookie_dir: cookie_dir = '/'
domain = wikiutil.getCookieDomain(self.request)
expirestr = time.strftime("%A, %d-%b-%Y %H:%M:%S GMT",
time.gmtime(0))
self.request.setHttpHeader(('Set-Cookie',
('%s="%s"; domain=%s; path=%s; '
'expires=%s' % (
(cookie_id, cookie[cookie_id].value,
domain, cookie_dir, expirestr)))))
self.request.saved_cookie = ''
self.request.auth_username = ''
self.request.user = user.User(self.request)
return msg + _("Cookie deleted. You are now logged out.")
if form.has_key('login_sendmail'):
if not self.request.isPOST():
return "Use the interactive interface to change settings!"
if not config.mail_smarthost:
return _('This wiki is not enabled for mail processing. '
'Contact the owner of the wiki, who can either enable '
'email, or remove the "Subscribe" icon.')
try:
email = form['email'][0]
except KeyError:
return _("Please provide a valid email address!")
text = ''
uid = user.getUserIdByEmail(email, self.request)
if uid:
theuser = user.User(self.request, uid)
if theuser.valid:
code = self.createCode(theuser.id)
sitename = farm.getBaseWikiFullName(self.request)
if config.wiki_farm:
url = farm.getBaseFarmURL(self.request)
else:
url = '%s/' % self.request.getBaseURL()
text = ("Go here to automatically log into %s: "
"%s%s?action=userform&uid=%s&code=%s\n"
"Once you're logged in, you should change your "
"password in your settings "
"(you forgot your password, right?).\n\n"
"(The link in this email is good for "
"one use only.)" % (
sitename, url,
wikiutil.quoteWikiname(
config.page_user_preferences),
theuser.id, code))
if not text:
return _("Found no account matching the given email address "
"'%(email)s'!") % {'email': email}
mailok, msg = util.mail.sendmail(self.request, [email],
'Your wiki account data', text, mail_from=config.mail_from)
return wikiutil.escape(msg)
if form.has_key('login') or form.has_key('uid'):
uid = None
if form.has_key('code') and form.has_key('uid'):
given_uid = form['uid'][0].strip()
given_code = form['code'][0].strip()
given_code
if self.isValidCode(given_uid, given_code):
uid = given_uid
if uid:
# we were given account information so let's
# create an account -> log them in
theuser = user.User(self.request, id=uid)
msg = _("You are now logged in! "
"Please change your password below!")
# send the cookie
theuser.sendCookie(self.request)
self.request.user = theuser
return msg
else:
# we weren't given information, so let's see
# if they gave us a login/password
# try to get the user name
try:
name = form['username'][0].replace('\t', ' ').strip()
except KeyError:
name = ''
# try to get the password
password = form.get('password',[''])[0]
# load the user data and check for validness
if name:
theuser = user.User(self.request, name=name,
password=password, is_login=True)
else:
theuser = user.User(self.request, id=uid, name=name,
password=password, is_login=True)
if config.wiki_farm:
wiki_base_url = farm.getBaseFarmURL(self.request)
else:
wiki_base_url = '%s/' % self.request.getScriptname()
if not theuser.valid:
if (not self.request.form.has_key('backto_wiki') or not
self.request.form['backto_wiki'][0]):
return_string = ('Unknown username or wrong password.'
'<br/><br/>New user? '
'<a href="%s%s?new_user=1">'
'Click here to create an account!</a>'
'<br/><br/>Forgot your password? '
'We\'ll email it to you.'
'<form action="%s" method="POST">'
'<input type="hidden" name="action" '
'value="userform">'
'Email address: '
'<input class="formfields" '
'type="text" name="email">'
' '
'<input type="submit" '
'class="formbutton" '
'name="login_sendmail" '
'value="Mail me my account '
'data">'
'</form>' % (
wiki_base_url,
wikiutil.quoteWikiname(
config.page_user_preferences),
wiki_base_url))
return return_string
else:
self.request.http_redirect(
urllib.unquote(
self.request.form['backto_page'][0].encode(
config.charset)) +
'?action=userform&badlogin=1')
return
# send the cookie
theuser.sendCookie(self.request)
self.request.user = theuser
send_back_home(self.request, msg="You are now logged in!")
else:
if not self.request.isPOST():
return """Use the interactive interface to change settings!"""
# save user's profile, first get user instance
theuser = user.User(self.request)
# try to get the name
# if name is empty or missing, return an error msg
if (form.has_key('username') and
form['username'][0].replace('\t', '').strip()):
theuser.propercased_name = \
form['username'][0].replace('\t', ' ').strip()
theuser.name = theuser.propercased_name.lower()
elif form.has_key('username'):
raise BadData, (_("Please enter a user name!"), new_user)
if (self.request.user.name and
(self.request.user.name != theuser.name)):
# they are still logged on and are trying to make a new account
raise BadData, (_("Please log out before creating an account."),
new_user)
if user.getUserId(theuser.name, self.request):
if theuser.name != self.request.user.name:
raise BadData, (_("User name already exists!"), new_user)
else:
new_user = False
if form.has_key('save') and form['save'][0] == 'Change password':
# change password setting
# try to get the password and pw repeat
password = form.get('password', [''])[0]
password2 = form.get('password2',[''])[0]
# Check if password is given and matches with password repeat
if password != password2:
raise BadData, (_("Passwords don't match!"), new_user)
if not password and new_user:
raise BadData, (_("Please specify a password!"), new_user)
if password:
theuser.enc_password = user.generate_hash(password)
self._clear_all_sessions_except_current()
msg = _("Password changed!")
else:
# process general settings
# tr to get the email
theuser.email = form.get('email', [''])[0]
if theuser.email:
email_user_id = user.getUserIdByEmail(theuser.email,
self.request)
else:
email_user_id = None
if not theuser.email or not re.match(".+@.+\..{2,}",
theuser.email):
raise BadData, (_("Please provide your email address - "
"without that you could not "
"get your login data via email just in "
"case you lose it."), new_user)
elif email_user_id and email_user_id != theuser.id:
raise BadData, (_("Somebody else has already registered "
"with the email address \"%s\", please "
"pick something else." % theuser.email),
new_user)
# editor size
theuser.edit_rows = util.web.getIntegerInput(self.request,
'edit_rows', theuser.edit_rows, 10, 60)
theuser.edit_cols = util.web.getIntegerInput(self.request,
'edit_cols', theuser.edit_cols, 30, 100)
# time zone
tz = form.get('tz', theuser.tz)[0]
if tz not in pytz.common_timezones:
tz = theuser.tz
theuser.tz = tz
wiki_for_userpage = form.get('wiki_for_userpage',
[''])[0].lower()
if (wiki_for_userpage and not
wikiutil.isInFarm(wiki_for_userpage, self.request)):
raise BadData, (_('"%s" is not the name of a wiki.' % (
wiki_for_userpage)), new_user)
if wiki_for_userpage != theuser.wiki_for_userpage:
# they have changed the wiki! time to do
# something differently
msg = _("<p>User preferences saved!</p>"
"<p><strong>Note:</strong> It may take a bit for "
"all links to your name to point to the "
"new wiki.</p>")
theuser.wiki_for_userpage = wiki_for_userpage
# User CSS URL
theuser.css_url = form.get('css_url', [''])[0]
# try to get the (optional) preferred language
#theuser.language = form.get('language', [''])[0]
# checkbox options
keys = []
for key in user_checkbox_fields:
value = form.get(key, [0])[0]
try:
value = int(value)
except ValueError:
pass
setattr(theuser, key, value)
if new_user:
# strip spaces, we don't allow them anyway
theuser.propercased_name = theuser.propercased_name.strip()
theuser.name = theuser.propercased_name.lower()
if not theuser.name.strip():
raise BadData, (_("Please provide a user name!"), new_user)
elif theuser.propercased_name.find(' ') != -1:
raise BadData, (_("Invalid username: spaces are not "
"allowed in user names"), new_user)
elif re.search('[%s]' % re.escape(USER_NOT_ALLOWED_CHARS),
theuser.propercased_name):
raise BadData, (_("Invalid username: the characters "
"%s are not allowed in usernames." % (
wikiutil.escape(
USER_NOT_ALLOWED_CHARS))),
new_user)
# messes up subpages.
# '/' isn't allowed, so we just disallow this and we're cool.
elif theuser.name == '..' or theuser.name == '.':
raise BadData, (_("Invalid username: okay, seriously, "
"that's a pretty lame name. "
"Pick something better!"), new_user)
elif len(theuser.propercased_name) > MAX_USERNAME_LENGTH:
raise BadData, (_("Invalid username: a username can be "
"at most %s characters long." % (
MAX_USERNAME_LEGNTH)), new_user)
elif (not theuser.email or not
re.match(".+@.+\..{2,}", theuser.email)):
raise BadData, (_("Please provide your email address - "
"without that you could not get your "
"login data via email just in case you "
"lose it."), new_user)
name_exists = user.getUserId(theuser.name, self.request)
if name_exists:
raise BadData, (_("This user name already belongs to "
"somebody else."), new_user)
email_exists = user.getUserIdByEmail(theuser.email,
self.request)
if email_exists:
raise BadData, (_("This email already belongs to somebody "
"else."), new_user)
# try to get the password and pw repeat
password = form.get('password', [''])[0]
password2 = form.get('password2',[''])[0]
# Check if password is given and matches with password repeat
if password != password2:
raise BadData, (_("Passwords don't match!"), new_user)
if not password and new_user:
raise BadData, (_("Please specify a password!"), new_user)
if password:
theuser.enc_password = user.generate_hash(password)
theuser.anonymous = False
# save data and send cookie
theuser.save(new_user=new_user)
theuser.sendCookie(self.request)
self.request.user = theuser
from Sycamore.formatter.text_html import Formatter
formatter = Formatter(self.request)
if not new_user:
if not msg:
msg = _("User preferences saved!")
if self.from_wiki:
go_back_to_wiki = farm.link_to_wiki(self.from_wiki, formatter)
msg = ('%s<br/><br/>Wanna go '
'back to %s?' % (msg, go_back_to_wiki))
else:
msg = _("Account created! You are now logged in.")
self.request.user.valid = 1
if (self.from_wiki and self.from_wiki.lower() !=
farm.getBaseWikiName()):
go_back_to_wiki = farm.link_to_wiki(self.from_wiki, formatter)
msg = ('%s<br/><br/>Head back over to %s and your new account '
'should work there!' % (msg, go_back_to_wiki))
if _debug:
msg = msg + util.dumpFormData(form)
return msg
def execute(pagename, request):
from Sycamore.PageEditor import PageEditor
_ = request.getText
actname = __name__.split('.')[-1]
page = Page(pagename, request)
msg = None
form = request.form
wikiname = None
if not config.wiki_farm or not config.allow_web_based_wiki_creation:
return page.send_page(msg='You are not allowed to create new wikis.')
if not request.user.valid:
return page.send_page(msg='You must be logged in to create new wikis.')
if do_email_auth:
if request.form.has_key('send_email') and request.form['send_email'][0]:
if (not request.form.has_key('wikiname') or not
request.form['wikiname'][0]):
return page.send_page(msg='Missing wiki name.')
wikiname = request.form['wikiname'][0].lower()
if not farm.isValidWikiName(wikiname):
msg = ('Wiki creation failed because the wiki name "%s" is '
'invalid. You may only use the numbers 0-9, the '
'letters a-z, and the dash "-" in a wiki name.' %
wikiname)
elif wikiutil.isInFarm(wikiname, request):
msg = 'Wiki "%s" already exists!' % wikiname
else:
msg = send_validation_email(wikiname, request)
return page.send_page(msg=msg)
email_code = has_valid_email_link(request)
if not email_code:
return page.send_page(msg=("Invalid email link. "
"To create a wiki you must follow the link send to your email account."))
if form.has_key('wikiname') and form['wikiname'][0]:
can_create_wiki = False
wikiname = form['wikiname'][0].lower()
if do_email_auth:
if not config.captcha_support:
can_create_wiki = True
elif form.has_key('captcha_id') and form.has_key('captcha_code'):
this_captcha = captcha.Captcha(page, id=form['captcha_id'][0])
if this_captcha.check(form['captcha_code'][0]):
can_create_wiki = True
else:
msg = ('Human verification was incorrect. '
'Please try again!')
else:
if form.has_key('audio'):
type = 'wav'
else:
type = 'png'
captcha.send_captcha(page, wikiname, actname, email_code, type)
return
else:
can_create_wiki = True
if can_create_wiki:
msg = farm.create_wiki(wikiname, request.user.name, request)
if do_email_auth:
_clearAuthCode(request, wikiname, email_code)
if msg:
# there was a problem
return page.send_page(msg=msg)
farm.add_wiki_to_watch(wikiname, request)
formatter = Formatter(request)
wiki_location = farm.link_to_wiki(wikiname, formatter)
msg = (
'Wiki "%s" created successfully! '
'Follow this link to get to your wiki:\n'
'<p>\n'
'%s\n'
'</p>\n'
'<p>\n'
'The wiki was added to your list of watched wikis '
'(change in '
'<a href="%sUser_Settings">your account settings</a>).\n'
'</p>' %
(wikiname, wiki_location, farm.getBaseFarmURL(request)))
return page.send_page(msg=msg)
