def events(request, file):
"""
Export all of the events data.
"""
events_page = Page('Events Board', request)
if (not command_line and not request.user.may.read(events_page)):
return
start_events(request, file)
request.cursor.execute(
"""SELECT event_time, posted_by, location, event_name,
posted_by_ip, posted_time, text
FROM events WHERE wiki_id=%(wiki_id)s""",
{'wiki_id': request.config.wiki_id})
for result in request.cursor.fetchall():
d = {
'event_time': result[0],
'posted_by': result[1],
'location': result[2],
'event_name': result[3],
'posted_by_ip': result[4],
'posted_time': result[5]
}
text = result[6]
file.write('<event %s>' % generate_attributes(d))
file.write(text.encode(config.charset))
file.write('</event>\n')
end_events(request, file)
def get_versions(page, file):
"""
Write the text for all the versions of the page.
"""
page.request.cursor.execute(
"""SELECT propercased_name, editTime, userEdited, editType,
comment, userIP
from allPages
where name=%(pagename)s and wiki_id=%(wiki_id)s
order by editTime desc""", {
'pagename': page.page_name,
'wiki_id': page.wiki_id
})
for result in page.request.cursor.fetchall():
d = {
'propercased_name': result[0],
'edit_time': result[1],
'user_edited': get_username(result[2], page.request),
'edit_type': result[3].strip(),
'comment': result[4],
'user_ip': result[5]
}
file.write('<version %s>\n' % generate_attributes(d))
version = Page(page.page_name, page.request, prev_date=d['edit_time'])
get_page_text(version, file)
file.write('</version>\n')
def execute(pagename, request):
page = Page(pagename, request)
msg = None
form = request.form
if form.has_key('id'):
id = request.form['id'][0]
return send_human_readable(id, request)
return page.send_page(msg=msg)
def sendCancel(self, newtext, datestamp):
"""
User clicked on Cancel button.
@param newtext: the edited text (which has been cancelled)
@param datestamp: ...
"""
_ = self._
backto = self.request.form.get('backto', [None])[0]
page = backto and Page(backto, self.request) or self
page.send_page(msg=_('Edit was cancelled.'))
def execute(pagename, request):
_ = request.getText
page = Page(pagename, request.cursor)
if request.user.may.read(pagename):
badwords, badwords_re, msg = checkSpelling(page, request)
else:
badwords = []
msg = _("You can't check spelling on a page you can't read.")
if badwords:
page.send_page(request, msg=msg, hilite_re=badwords_re)
else:
page.send_page(request, msg=msg)
def getPageList(request, objects=True):
"""
Generate a "master" pagelist of all pages that have
ever existed!
"""
request.cursor.execute(
"""SELECT name FROM allPages
WHERE wiki_id=%(wiki_id)s
GROUP BY name""", {'wiki_id': request.config.wiki_id})
page_list = []
for result in request.cursor.fetchall():
page_name = result[0]
if objects:
page_list.append(Page(page_name, request))
else:
page_list.append(page_name)
return page_list
def execute(pagename, request):
page = Page(pagename, request)
gmaps_api_key = request.config.gmaps_api_key or config.gmaps_api_key
script_loc = (
'<script src="http://maps.google.com/maps?file=api&v=2&key=%s" '
'type="text/javascript"></script>' % gmaps_api_key)
script_loc += ('<script src="%s/wiki/gmap.js" type="text/javascript">'
'</script>' % config.web_dir)
wiki_name, page_locs, nearby_locs = get_map_info(request)
map_html = mapJS(wiki_name, page_locs, nearby_locs, request)
html = ('<html><head>%s</head>'
'<body onLoad="loadMap();" style="padding:0;margin:0;">'
'<div id="map" style="width: 450px; height: 300px; margin:0; '
'padding:0; border:none;">'
'</div>%s</body></html>' % (script_loc, map_html))
request.http_headers()
request.write(html)
def writeEvent(request, event_text, event_name, event_location,
event_time_unix, posted_by):
posted_time = time.time()
if config.db_type == 'mysql':
request.cursor.execute(
"""INSERT into events
(uid, event_time, posted_by, text, location, event_name,
posted_time, posted_by_ip, wiki_id)
values (NULL, %(event_time_unix)s, %(posted_by)s,
%(event_text)s, %(event_location)s, %(event_name)s,
%(posted_time)s, %(userip)s, %(wiki_id)s)""",
{'id':id, 'event_time_unix':event_time_unix, 'posted_by':posted_by,
'event_text':event_text, 'event_location':event_location,
'event_name':event_name, 'posted_time':posted_time,
'userip':request.remote_addr, 'wiki_id':request.config.wiki_id},
isWrite=True)
else:
request.cursor.execute(
"""INSERT into events
(uid, event_time, posted_by, text, location, event_name,
posted_time, posted_by_ip, wiki_id)
values (NEXTVAL('events_seq'), %(event_time_unix)s,
%(posted_by)s, %(event_text)s, %(event_location)s,
%(event_name)s, %(posted_time)s, %(userip)s,
%(wiki_id)s)""",
{'id':id, 'event_time_unix':event_time_unix, 'posted_by':posted_by,
'event_text':event_text, 'event_location':event_location,
'event_name':event_name, 'posted_time':posted_time,
'userip':request.remote_addr,
'wiki_id':request.config.wiki_id}, isWrite=True)
if config.memcache:
# clear out today's events cache if the event is for today
event_time_struct = time.gmtime(event_time_unix +
request.config.tz_offset)
event_day_unix = calendar.timegm(
list(event_time_struct[0:3]) + [0,0,0,0,0,0])
today_struct = time.gmtime(posted_time+request.config.tz_offset)
today = list(today_struct[0:3]) + [0,0,0,0,0,0]
today_unix = calendar.timegm(today)
if event_day_unix == today_unix:
request.mc.delete("today_events")
caching.updateRecentChanges(Page("Events Board", request))
def mapJS(wiki_name, page_locs, nearby_locs, request):
"""
Create a string containing javascript for google map
page = the page object
place = place object of center of map
nearby = dictionary of nearby places
"""
# pick center point as the first point if there's more than one point
# associated with the page
center = page_locs[0]
pagename = center.pagename
page = Page(pagename, request, wiki_name=wiki_name)
out = """
<script type="text/javascript">
//<![CDATA[
function doLoad() {
var map = new GMap2(document.getElementById("map"));
map.addControl(new GSmallMapControl());
map.addControl(new GMapTypeControl());
map.setCenter(new GLatLng(%s,%s),16);
""" % (center.latitude, center.longitude)
nearbys_processed = {}
i = 0 # for 'a' 'b' labels on markers
if nearby_locs:
for x in nearby_locs:
nearby_page = Page(x.pagename, request, wiki_name=wiki_name)
if (x.pagename, x.latitude, x.longitude) in nearbys_processed:
# only plot a given nearby point once
# (it is sometimes easier to just have repeated nearbys
# in the query, hence we filter them out here)
continue
namestr = ("""'<b><a href="%s" target=_parent>%s</a></b>"""
"""<br>%s'""" % (nearby_page.url(relative=False),
x.pagename.replace("'", "\\" + "'"),
x.address.replace("'", "\\" + "'")))
out += """
var point = new GLatLng(%s,%s);
map.addOverlay(createMarker(point,%s, %s));
""" % (x.latitude, x.longitude, i, namestr)
# add it as plotted
nearbys_processed[(x.pagename, x.latitude, x.longitude)] = None
i += 1
for x in page_locs:
namestr = (
"""'<b><a href="%s" target=_parent>%s</a></b>"""
"""<br>%s'""" %
(page.url(relative=False), x.pagename.replace(
"'", "\\" + "'"), x.address.replace("'", "\\" + "'")))
out += ("var p_point = new GLatLng(%s,%s);\n"
"var myArrow = createArrow(p_point,%s);\n"
"map.addOverlay(myArrow);\n"
"GEvent.trigger(myArrow,'click');" %
(x.latitude, x.longitude, namestr))
out += """
loaded = true;
}
//]]>
</script>"""
return out
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)
def execute(pagename, request):
_ = request.getText
actname = __name__.split('.')[-1]
page = PageEditor(pagename, request)
msg = ''
oldtext = page.get_raw_body().lower()
events_page = Page("Events Board", request)
# Do we want an RSS feed?
if (request.form.has_key('rss') and request.form.get("rss")[0] == '1' and
request.user.may.read(events_page)):
request.http_headers()
request.write(doRSS(request))
raise util.SycamoreNoFooter
return
# be extra paranoid
elif (actname in config.excluded_actions or
not request.user.valid or not request.user.may.edit(events_page) or
not request.user.may.edit(page)):
msg = _('You are not allowed to edit this page. '
'(You need an account in most cases)')
# check to make sure the events macro is in the page
elif string.find(oldtext,"[[events]]") == -1:
msg = _('Not allowed to add an event')
# check whether page exists at all
elif not page.exists():
msg = _('This page does not exist.')
# check whether the user filled out the form
elif request.form.has_key('uid') and request.form.has_key('del'):
if (request.form.get('del')[0] == "1" and
request.user.may.admin(Page("Events Board", request))):
# let's try and delete the event!
uid = request.form.get('uid')[0]
request.cursor.execute(
"SELECT event_name from events where uid=%(uid)s", {'uid':uid})
name = request.cursor.fetchone()[0]
request.cursor.execute(
"DELETE from events where uid=%(uid)s", {'uid':uid},
isWrite=True)
msg = 'Event "%s" <b>deleted</b>!' % name
elif request.form.get('del')[0] == "1":
uid = request.form.get('uid')[0]
request.cursor.execute(
"SELECT event_name from events where uid=%(uid)s", {'uid':uid})
name = request.cursor.fetchone()[0]
request.cursor.execute(
"""DELETE from events where uid=%(uid)s and
posted_by=%(username)s""",
{'uid':uid, 'username':request.user.propercased_name},
isWrite=True)
msg = 'Event "%s" <b>deleted</b>!' % name
if config.memcache:
request.mc.set("today_events", None)
caching.updateRecentChanges(Page("Events Board", request))
elif (request.form.has_key('button') and
request.form.has_key('event_text') and
request.form.has_key('event_name') and
request.form.has_key('event_location') and
request.form.has_key('month') and
request.form.has_key('day') and
request.form.has_key('hour') and
request.form.has_key('minute') and
request.form.has_key('ticket')):
# check whether this is a valid renaming request (make outside
# attacks harder by requiring two full HTTP transactions)
if not _checkTicket(request.form['ticket'][0]):
msg = _('Please use the web interface to change the page!')
else:
event_text = request.form.get('event_text')[0]
event_name = request.form.get('event_name')[0]
event_location = request.form.get('event_location')[0]
month = int(request.form.get('month')[0])
day = int(request.form.get('day')[0])
hour = int(request.form.get('hour')[0])
minute = int(request.form.get('minute')[0])
year = int(request.form.get('year')[0])
posted_by = request.user.propercased_name
now = request.user.getFormattedDateTime(time.time(),
global_time=True)
# WE NEED TO VALIDATE THE TEXT AND THE OTHER FIELDS
if (isValid(event_text, event_name, event_location, month, day,
hour, minute, year) and not
hasPassed(month, day, hour,minute, year, request)):
event_time_unix = wikiutil.timeInTzToUTC(
request.config.tz,
(year, month, day, hour, minute, 0, 0))
writeEvent(request, event_text, event_name,
event_location, event_time_unix, posted_by)
msg = _('Your event has been added!')
elif hasPassed(month,day,hour,minute,year,request):
msg = _('Event time is in the past! '
'Please choose a time in the future.')
else:
msg = _('Event <b>NOT</b> posted. '
'You entered some invalid text into the form. '
'No HTML is allowed.')
else:
msg = _('Please fill out all fields of the form.')
return page.send_page(msg)
def doRSS(request):
"""
set up the RSS file
"""
rss_init_text = (
'<?xml version="1.0" ?>\n'
'<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">\n'
'<channel><title>%s Events Board</title><link>%s</link>'
'<description>'
'Events occuring soon, taken from the %s Events Board.'
'</description><language>en-us</language>\n'
'</channel>\n'
'</rss>\n' % (request.config.sitename,
Page("Events Board", request).link_to(),
request.config.sitename))
creator_text = 'The %s Robot' % request.config.sitename
rss_dom = xml.dom.minidom.parseString(rss_init_text)
channel = rss_dom.getElementsByTagName("channel")[0]
# Check to see if the event has already passed
import string, re
current_time = request.user.getFormattedDateTime(time.time(),
global_time=True)
year_cut = string.split(current_time," ")[0]
current_year = string.split(year_cut, "-")[0]
month_cut = string.split(current_time," ")[0]
current_month = string.split(month_cut,"-")[1]
day_cut = string.split(current_time," ")[0]
current_day = string.split(day_cut,"-")[2]
hour_cut = string.split(current_time," ")[1]
current_hour = string.split(hour_cut,":")[0]
string_month = findMonth(current_month)
rss_text = []
events = []
timenow = time.time()
today_struct = time.gmtime(timenow+request.config.tz_offset)
today = list(today_struct[0:3]) + [0,0,0,0,0,0]
today = calendar.timegm(today) - request.config.tz_offset
tomorrow_struct = time.gmtime(timenow+60*60*24+request.config.tz_offset)
tomorrow = list(tomorrow_struct[0:3]) + [0,0,0,0,0,0]
tomorrow = calendar.timegm(tomorrow) - request.config.tz_offset
request.cursor.execute(
"""SELECT uid, event_time, posted_by, text, location, event_name
from events where event_time >= %(today)s and
event_time < %(tomorrow)s and
wiki_id=%(wiki_id)s""",
{'today':today, 'tomorrow':tomorrow, 'wiki_id':request.config.wiki_id})
result = request.cursor.fetchone()
while result:
events.append(result)
result = request.cursor.fetchone()
for event in events:
event_time_unix = event[1]
# stupid date stuff
time_struct = time.gmtime(event_time_unix+request.config.tz_offset)
year = time_struct[0]
month = time_struct[1]
day = time_struct[2]
hour = time_struct[3]
minute = time_struct[4]
posted_by = event[2]
event_location = event[4]
event_name = event[5]
id = event[0]
text = event[3]
if event_name:
processed_name = wikiutil.simpleStrip(request,event_name)
else:
processed_name = ''
processed_text = doParse(text,request)
processed_location = doParse(event_location,request)
if int(hour) > 12 :
read_hour = int(hour) - 12
if not int(minute) == 0:
ptime = str(read_hour) + ":" + str(minute) + " PM"
else:
ptime = str(read_hour) + ":00" + " PM"
elif int(hour) == 0:
if not int(minute) == 0:
ptime = "12:" + str(minute) + " AM"
else:
ptime = "12:00 AM"
elif int(hour) == 12:
if not int(minute) == 0:
ptime = "12:" + str(minute) + " PM"
else:
ptime = "12:00 PM"
else:
if not int(minute) == 0:
ptime = str(hour) + ":" + str(minute) + " AM"
else:
ptime = str(hour) + ":00 AM"
total_date = "%s, %s %s" % (
datetoday(int(day), int(month), int(year)), findMonth(month), day)
item = rss_dom.createElement("item")
rss_text = []
rss_text.append('<b>Date:</b> %s<br>\n'
'<b>Time:</b> %s<br>\n'
'<b>Location:</b> %s<br><br>\n'
'%s (Posted by %s)\n' %
(total_date, ptime, processed_location, processed_text,
user.getUserLink(request,
user.User(request, name=posted_by),
absolute=True)))
item_guid = rss_dom.createElement("guid")
item_guid.setAttribute("isPermaLink","false")
item_guid.appendChild(rss_dom.createTextNode(''.join(str(id))))
item.appendChild(item_guid)
item_description = rss_dom.createElement("description")
item_description.appendChild(rss_dom.createTextNode(''.join(rss_text)))
item_title = rss_dom.createElement("title")
item_title.appendChild(rss_dom.createTextNode(processed_name))
item.appendChild(item_title)
item_link = rss_dom.createElement("link")
item_link.appendChild(rss_dom.createTextNode(
Page("Events Board", request).url(relative=False)))
item.appendChild(item_link)
item_date = rss_dom.createElement("dc:date")
item_date.appendChild(rss_dom.createTextNode(
"%s-%s-%s" % (current_year,current_month,current_day)))
item.appendChild(item_date)
creator = rss_dom.createElement("dc:creator")
creator.appendChild(rss_dom.createTextNode(creator_text))
item.appendChild(creator)
item.appendChild(item_description)
channel.appendChild(item)
the_xml = rss_dom.toxml()
return the_xml
def sendEditor(self, **kw):
"""
Send the editor form page.
@keyword preview: if given, show this text in preview mode
@keyword staytop: don't go to #preview
@keyword comment: comment field (when preview is true)
@keyword had_conflict: we had an edit conflict on a save.
"""
import re
try:
from Sycamore.action import SpellCheck
except ImportError:
SpellCheck = None
form = self.request.form
_ = self._
self.request.http_headers([("Content-Type", "text/html; charset=%s" %
config.charset)] + self.request.nocache)
msg = None
preview = kw.get('preview', None)
emit_anchor = not kw.get('staytop', 0)
proper_name = self.proper_name()
from Sycamore.formatter.text_html import Formatter
self.request.formatter = Formatter(self.request,
store_pagelinks=1,
preview=preview)
base_uri = "%s/%s?action=edit" % (self.request.getScriptname(),
wikiutil.quoteWikiname(
self.proper_name()))
backto = form.get('backto', [None])[0]
if backto:
base_uri += '&' + util.web.makeQueryString(backto=backto)
# check edit permissions
if not self.request.user.may.edit(self):
msg = _('You are not allowed to edit this page.')
elif self.prev_date:
# Trying to edit an old version, this is not possible via
# the web interface, but catch it just in case...
msg = _('Cannot edit old revisions!')
# Did one of the prechecks fail?
if msg and not kw.get('had_conflict', None):
self.send_page(msg=msg)
return
# check for preview submit
if preview is None:
title = _('Edit "%(pagename)s"')
else:
title = _('Preview of "%(pagename)s"')
self.set_raw_body(preview.replace("\r", ""), 1)
page_needle = self.page_name
if config.allow_subpages and page_needle.count('/'):
page_needle = '/' + page_needle.split('/')[-1]
wikiutil.send_title(
self.request,
self.proper_name(),
pagename=self.proper_name(),
has_link=True,
strict_title='Editing "%s"' % self.proper_name(),
body_onload="sizeForIE('savetext', 100, 'editorComment', 99);")
# start content div
self.request.write('<div id="content" class="content">\n')
# get request parameters
text_rows = None
if form.has_key('rows'):
text_rows = int(form['rows'][0])
if self.request.user.valid:
# possibly update user's pref
if text_rows != self.request.user.edit_rows:
self.request.user.edit_rows = text_rows
self.request.user.save()
else:
text_rows = config.edit_rows
if self.request.user.valid:
text_rows = int(self.request.user.edit_rows)
if form.has_key('cols'):
text_cols = int(form['cols'][0])
if self.request.user.valid:
# possibly update user's pref
if text_rows != self.request.user.edit_rows:
self.request.user.edit_rows = text_rows
self.request.user.save()
else:
text_cols = 80
if self.request.user.valid:
text_cols = int(self.request.user.edit_cols)
# check datestamp (version) of the page our edit is based on
if preview is not None:
# propagate original datestamp
mtime = float(form['datestamp'][0])
# did someone else change the page while we were editing?
conflict_msg = None
if not self.exists():
# page does not exist, are we creating it?
if mtime:
conflict_msg = _('<p>Someone else <b>deleted</b> this '
'page while you were editing!')
elif mtime != self.mtime():
conflict_msg = _('<p>Someone else changed this page while '
'you were editing.')
# merge conflicting versions
allow_conflicts = 1
from Sycamore.util import diff3
savetext = self.get_raw_body()
oldpg = Page(self.page_name, self.request, prev_date=mtime)
original_text = oldpg.get_raw_body()
saved_text = Page(self.page_name, self.request).get_raw_body()
verynewtext, had_conflict = diff3.text_merge(
original_text,
saved_text,
savetext,
marker1='----- /!\ Edit conflict! Your version: -----\n',
marker2='----- /!\ Edit conflict! Other version: -----\n',
marker3='----- /!\ End of edit conflict -----\n')
if had_conflict and self.request.user.valid and (
self.request.user.id == self.last_edit_info()[1]):
# user pressed back button or did something weird
conflict_msg = None
elif had_conflict:
conflict_msg = _(conflict_msg +
'There was an <b>edit conflict between '
'your changes!</b></p>'
'<p>Please review the conflicts and '
'merge the changes.</p>')
mtime = self.mtime()
self.set_raw_body(verynewtext, 1)
else:
conflict_msg = _(conflict_msg +
'Your changes were sucessfully merged!')
mtime = self.mtime()
self.set_raw_body(verynewtext)
if conflict_msg:
self.request.write('<div id="message"><div>%s'
'</div></div>' % conflict_msg)
emit_anchor = 0 # make this msg visible!
elif self.exists():
# datestamp of existing page
mtime = self.mtime()
else:
# page creation
mtime = 0
# output message
message = kw.get('msg', '')
if message:
self.request.write('<div id="message">%s</div>' % (message))
# get the text body for the editor field
if form.has_key('template'):
# "template" parameter contains the name of the template page
template_page = wikiutil.unquoteWikiname(form['template'][0])
raw_body = Page(template_page, self.request).get_raw_body()
else:
raw_body = self.get_raw_body()
# send text above text area
# button toolbar
self.request.write('<div id="editArea">')
self.request.write(
"<script type=\"text/javascript\">"
"var buttonRoot = '%s';</script>" % (os.path.join(
config.url_prefix, self.request.theme.name, 'img', 'buttons')))
if self.request.user.name:
if config.user_page_prefix:
self.request.write(
"<script type=\"text/javascript\">"
"var userPageLink = '[\"%s%s\"]';</script>" %
(config.user_page_prefix,
self.request.user.propercased_name))
else:
self.request.write("<script type=\"text/javascript\">"
"var userPageLink = '[\"%s\"]';</script>" %
(config.user_page_prefix,
self.request.user.propercased_name))
else:
self.request.write("<script type=\"text/javascript\">"
"var userPageLink = '%s';</script>" %
(self.request.remote_addr))
if config.wiki_farm:
self.request.write(
"<script type=\"text/javascript\" "
"src=\"http://%s%s%s/edit.js\"></script>\n" %
(config.wiki_base_domain, config.web_dir, config.url_prefix))
else:
self.request.write("<script type=\"text/javascript\" "
"src=\"%s%s/edit.js\"></script>\n" %
(config.web_dir, config.url_prefix))
# send form
self.request.write('<form name="editform" id="editform" '
'method="post" action="%s/%s#preview">' %
(self.request.getScriptname(),
wikiutil.quoteWikiname(proper_name)))
self.request.write(
str(html.INPUT(type="hidden", name="action", value="savepage")))
if backto:
self.request.write(
str(html.INPUT(type="hidden", name="backto", value=backto)))
# generate default content
if not raw_body:
if self.isTalkPage():
raw_body = _('This page is for discussing the '
'contents of ["%s"].') % self.proper_name()[:-5]
else:
raw_body = _('Describe %s here.') % (self.proper_name(), )
# replace CRLF with LF
raw_body = self._normalize_text(raw_body)
# send datestamp (version) of the page our edit is based on
self.request.write('<input type="hidden" name="datestamp" '
'value="%s">' % repr(mtime))
# Print the editor textarea and the save button
self.request.write('<textarea id="savetext" name="savetext" '
'rows="%d" cols="%d" style="width:100%%;">%s'
'</textarea>' %
(text_rows, text_cols, wikiutil.escape(raw_body)))
# make sure we keep the template notice on a resize of the editor
template_param = ''
if form.has_key('template'):
template_param = '&template=' + form['template'][0]
# draw edit size links
self.request.write(
_('<div class="pageEditInfo" id="editorSize">'
'editor size:'))
self.request.write('<a href="#" onclick="return sizeEditor(\'bigger\','
'\'%s&preview=1&cols=60%s\')">%s'
'</a>' % (base_uri, template_param, '+'))
self.request.write(
',<a href="#" onclick="return sizeEditor(\'smaller\','
'\'%s&preview=1&cols=60%s\')">%s'
'</a>' % (base_uri, template_param, '-'))
self.request.write('</div>')
self.request.write('</p>') # close textarea
self.request.write(
'<div id="editComment" id="editorResizeButtons"> '
'%s<br><input type="text" class="formfields" '
'name="comment" id="editorComment" value="%s" '
'size="%d" maxlength="80" style="width:99%%;">'
'</div>' % (_("<font size=\"+1\">Please comment "
"about this change:</font>"),
wikiutil.escape(kw.get('comment', ''), 1), text_cols))
spam_catch_button = (
'<span style="position: absolute; top: 0px; left: 0px;'
'height: 0px; width: 0px; overflow: hidden;">'
'dont enter into this box:'
'<input type="text" name="text_dont"/>'
'</span>'
'<span style="position: absolute; top: 0px; left: 0px;'
'height: 0px; width: 0px; overflow: hidden;">'
'<input class="formbutton" type="submit" name="button_dont" '
'value="Dont press me">\n'
'</span>')
self.request.write(spam_catch_button)
# button bar
button_spellcheck = (
SpellCheck and
'<input type="submit" class="formbutton" name="button_spellcheck"'
' value="%s">' % _('Check Spelling')) or ''
save_button_text = _('Save Changes')
cancel_button_text = _('Cancel')
self.request.write("</div>")
if self.request.user.may.admin(self):
security_button = ('<input type="button" class="formbutton" '
'onClick="location.href='
'\'%s/%s?action=Security\'" '
'value="Security">') % (
self.request.getScriptname(),
wikiutil.quoteWikiname(proper_name))
else:
security_button = ''
if self.request.user.may.delete(self):
delete_button = ('<input type="button" class="formbutton" '
'onClick="location.href='
'\'%s/%s?action=DeletePage\'" value="Delete">'
) % (self.request.getScriptname(),
wikiutil.quoteWikiname(proper_name))
rename_button = ('<input type="button" class="formbutton" '
'onClick="location.href=\'%s/%s?action=Rename\'"'
' value="Rename">') % (self.request.getScriptname(
), wikiutil.quoteWikiname(proper_name))
else:
delete_button = ''
rename_button = ''
self.request.write(
'<div id="editButtonRow">'
'<span>'
'<input type="submit" class="formbutton" '
'name="button_preview" value="%s"> '
'<input type="submit" class="formbutton" '
'name="button_save" value="%s"> '
'<input type="submit" class="formbutton" '
'name="button_cancel" value="%s"> '
'</span>'
'<span class="editActions">'
'<input type="button" class="formbutton" '
'onClick="window.open(\'%s/%s?action=Files\', '
'\'files\', \'width=800,height=600,'
'scrollbars=1\')" value="Upload Files"> '
'%s '
'%s '
'%s '
'%s</span>'
'</div>' %
(_('Preview'), save_button_text, cancel_button_text,
self.request.getScriptname(), wikiutil.quoteWikiname(proper_name),
button_spellcheck, delete_button, rename_button, security_button))
if self.request.config.edit_agreement_text:
self.request.write(self.request.config.edit_agreement_text)
badwords_re = None
if preview is not None:
if SpellCheck and (form.has_key('button_spellcheck')
or form.has_key('button_newwords')):
badwords, badwords_re, msg = SpellCheck.checkSpelling(
self, self.request, own_form=0)
self.request.write("<p>%s</p>" % msg)
self.request.write("</form>")
if config.wiki_farm:
from Sycamore import farm
help_link = farm.link_to_page(farm.getBaseWikiName(),
"Help with Editing",
self.request.formatter,
force_farm=True)
else:
help_link = Page("Help with Editing", self.request).link_to()
# QuickHelp originally by Georg Mischler <*****@*****.**>
self.request.write(
'<h2>Editing quick-help</h2>\n'
'<dl><div style="float: right; margin: 10px; border: 1px solid; '
'padding: 3pt;">See <b>%s</b> for more information.</div>' %
(help_link) +
_("<dt>Emphasis:</dt>\n"
"<dd>''<em>italics</em>''; '''<strong>bold</strong>''';"
"'''''<strong><em>bold italics</em></strong>''''';"
"''<em>mixed '''<strong>bold</strong>''' and "
"italics</em>''; ---- horizontal rule.</dd>"
"<dt>Headings:</dt>"
"<dd>= Title 1 =; == Title 2 ==; === Title 3 ===;"
"==== Title 4 ====; ===== Title 5 =====.</dd>"
"<dt>Lists:</dt>"
"<dd>space and one of * bullets; 1., a., A., i., I. "
"numbered items;"
" 1.#n start numbering at n; space alone indents.</dd>"
"<dt>Links:</dt>"
"<dd>[\"brackets and double quotes\"]; [\"the exact "
"page name\" label];"
" url; [url]; [url label].</dd>"
"<dt>Tables:</dt>"
"<dd>|| cell text |||| cell text spanning two columns ||;"
" no trailing white space allowed after tables or titles."
"</dd></dl>"))
if preview is not None:
if not emit_anchor:
preview_name = "previewHide"
else:
preview_name = "preview"
self.request.write('<div id="%s" class="preview">' % preview_name)
self.send_page(content_only=1,
hilite_re=badwords_re,
preview=preview)
self.request.write('</div>')
self.request.write('</div>\n') # end content div
wikiutil.send_after_content(self.request)
self.request.theme.emit_custom_html(config.page_footer1)
self.request.theme.emit_custom_html(config.page_footer2)
self.request.write('</body></html>')
def checkSpelling(page, request, own_form=1):
"""
Do spell checking, return a tuple with the result.
"""
_ = request.getText
# first check to see if we we're called with a "newwords" parameter
if request.form.has_key('button_newwords'):
_addLocalWords(request)
# load words
wordsdict = _loadDict(request)
localwords = {}
lsw_page = Page(request.config.page_local_spelling_words, request)
if lsw_page.exists():
_loadWordsString(request, localwords, lsw_page.get_raw_body())
# init status vars & load page
badwords = {}
text = page.get_raw_body()
# checker regex and matching substitute function
word_re = re.compile(r'([%s]?[%s]+)' %
(config.upperletters, config.lowerletters))
def checkword(match,
wordsdict=wordsdict,
badwords=badwords,
localwords=localwords,
num_re=re.compile(r'^\d+$')):
word = match.group(1)
if len(word) == 1:
return ""
if not (wordsdict.has_key(word) or wordsdict.has_key(word.lower()) or
localwords.has_key(word) or localwords.has_key(word.lower())):
if not num_re.match(word):
badwords[word] = 1
return ""
# do the checking
for line in text.encode('utf-8').split('\n'):
if line == '' or line[0] == '#': continue
word_re.sub(checkword, line)
if badwords:
badwords = badwords.keys()
badwords.sort(lambda x, y: cmp(x.lower(), y.lower()))
# build regex recognizing the bad words
badwords_re = r'(^|(?<!\w))(%s)(?!\w)'
badwords_re = badwords_re % ("|".join(map(re.escape, badwords)), )
# XXX UNICODE re.UNICODE !?
badwords_re = re.compile(badwords_re)
lsw_msg = ''
if localwords:
lsw_msg = ' ' + _('(including %(localwords)d %(pagelink)s)') % {
'localwords': len(localwords),
'pagelink': lsw_page.link_to()
}
msg = _('The following %(badwords)d words could not be found '
'in the dictionary of '
'%(totalwords)d words%(localwords)s and are '
'highlighted below:') % {
'badwords': len(badwords),
'totalwords': len(wordsdict) + len(localwords),
'localwords': lsw_msg
} + "<br>"
# figure out what this action is called
action_name = os.path.splitext(os.path.basename(__file__))[0]
# add a form containing the bad words
if own_form:
msg = msg + ('<form method="POST" action="%s">'
'<input type="hidden" name="action" value="%s">' % (
page.url(request),
action_name,
))
checkbox = ('<input type="checkbox" name="newwords" '
'value="%(word)s">%(word)s ')
msg = msg + (
" ".join(
map(lambda w, cb=checkbox: cb % {
'word': wikiutil.escape(w),
},
badwords)) +
'<p><input type="submit" name="button_newwords" value="%s"></p>' %
_('Add checked words to dictionary'))
if own_form:
msg = msg + '</form>'
else:
badwords_re = None
msg = _("No spelling errors found!")
return badwords, badwords_re, msg
def execute(pagename, request):
_ = request.getText
page = Page(pagename, request)
actname = __name__.split('.')[-1]
if not request.user.may.admin(page):
msg = _("You don't have admin permissions on this page, "
"so you cannot change security settings.")
return page.send_page(msg)
if request.form.has_key('button'):
# process save
groups = []
groups_dict = {}
for key in request.form:
if key.endswith('_groupname'):
groups.append(unquoteWikiname(key[:-10]))
else:
if key.endswith('_may_read'):
dowhat = 'read'
groupname = unquoteWikiname(key[:-9])
elif key.endswith('_may_edit'):
dowhat = 'edit'
groupname = unquoteWikiname(key[:-9])
elif key.endswith('_may_delete'):
dowhat = 'delete'
groupname = unquoteWikiname(key[:-11])
elif key.endswith('_may_admin'):
dowhat = 'admin'
groupname = unquoteWikiname(key[:-10])
else:
continue
if not groups_dict.has_key(groupname):
groups_dict[groupname] = [False, False, False, False]
groups_dict[groupname][ACL_RIGHTS_TABLE[dowhat]] = True
# set groups we weren't sent any checkboxes for to
# all false (nothing checked)
groups_no_checks = filter(
lambda (groupname): (groupname not in groups_dict), groups)
for groupname in groups_no_checks:
groups_dict[groupname] = [False, False, False, False]
wikiacl.setACL(pagename, groups_dict, request)
return page.send_page(msg=_("Security settings sucessfully changed!"))
formhtml = ['<h3>Security settings for "%s":</h3>' % pagename]
button = _("Save")
url = page.url()
d = {'url': url, 'actname': actname, 'button': button}
formhtml.append(
'<form method="POST" action="%(url)s">\n'
'<input type="hidden" name="action" value="%(actname)s">\n' % d)
custom_groups = user.getGroupList(request, exclude_special_groups=True)
grouplist = ['All', 'Known'] + custom_groups
for groupname in grouplist:
# "All" and "Known" are a bit condense
if groupname == 'All':
written_groupname = 'Everybody'
elif groupname == 'Known':
written_groupname = 'Logged in people'
else:
written_groupname = groupname
group = wikiacl.Group(groupname, request, fresh=True)
# we want to show the 'change security' option only if
# it makes some sense
show_admin = groupname in custom_groups
formhtml.append('<h6>%s</h6>' % written_groupname)
formhtml.append('<input type="hidden" name="%s_groupname" '
'value="1">' % quoteWikiname(groupname))
if group.may(page, 'read'):
formhtml.append('<input type="checkbox" checked '
'name="%s_may_read" value="1">' %
quoteWikiname(groupname))
else:
formhtml.append('<input type="checkbox" name="%s_may_read" '
'value="1">' % quoteWikiname(groupname))
formhtml.append(' read ')
if group.may(page, 'edit'):
formhtml.append('<input type="checkbox" checked '
'name="%s_may_edit" value="1">' %
quoteWikiname(groupname))
else:
formhtml.append('<input type="checkbox" name="%s_may_edit" '
'value="1">' % quoteWikiname(groupname))
formhtml.append(' edit ')
if group.may(page, 'delete'):
formhtml.append('<input type="checkbox" checked '
'name="%s_may_delete" value="1">' %
quoteWikiname(groupname))
else:
formhtml.append('<input type="checkbox" name="%s_may_delete" '
'value="1">' % quoteWikiname(groupname))
formhtml.append(' delete ')
if show_admin:
if group.may(page, 'admin'):
formhtml.append('<input type="checkbox" checked '
'name="%s_may_admin" value="1">' %
quoteWikiname(groupname))
else:
formhtml.append('<input type="checkbox" name="%s_may_admin" '
'value="1">' % quoteWikiname(groupname))
formhtml.append(' change security ')
formhtml.append(
'<p><input type="submit" name="button" value="%(button)s">\n'
'</p>\n'
'</form>' % d)
page.send_page(msg=''.join(formhtml))
def copy_files(oldpagename, newpagename, request):
"""
copies files from oldpagename to newpagename.
keeps the files on oldpagename for manual deletion.
if there is an file on the page newpagename that has the same name as a
file on oldpagename, then the file from newpagename superseeds the old
file, and the old file is deleted (but kept as a deleted file as per usual
delete file/is accessable via the info tab)
"""
from Sycamore.action.Files import get_filelist
old_page_files = get_filelist(request, oldpagename)
new_page_files = get_filelist(request, newpagename)
for filename in old_page_files:
is_image = wikiutil.isImage(filename)
request.cursor.execute(
"""SELECT file, uploaded_time, uploaded_by, uploaded_by_ip,
attached_to_pagename_propercased from files
where name=%(filename)s and
attached_to_pagename=%(oldpagename)s and
wiki_id=%(wiki_id)s""", {
'filename': filename,
'oldpagename': oldpagename.lower(),
'wiki_id': request.config.wiki_id
})
result = request.cursor.fetchone()
if result:
old_page_file_dict = {
'filename': filename,
'uploaded_time': result[1],
'uploaded_by': result[2],
'attached_to_pagename_propercased': result[4],
'oldpagename': oldpagename.lower(),
'uploaded_by_ip': result[3],
'newpagename': newpagename.lower(),
'newpagename_propercased': Page(newpagename,
request).proper_name(),
'timenow': time.time(),
'userid': request.user.id,
'userip': request.remote_addr,
'wiki_id': request.config.wiki_id
}
if is_image:
request.cursor.execute(
"""SELECT xsize, ysize from imageInfo
where name=%(filename)s and
attached_to_pagename=%(oldpagename)s and
wiki_id=%(wiki_id)s""", {
'filename': filename,
'oldpagename': oldpagename.lower(),
'wiki_id': request.config.wiki_id
})
result = request.cursor.fetchone()
if result:
old_page_file_dict['xsize'] = result[0]
old_page_file_dict['ysize'] = result[1]
if filename not in new_page_files:
request.cursor.execute("""INSERT into files
(name, file, uploaded_time, uploaded_by, uploaded_by_ip,
attached_to_pagename, attached_to_pagename_propercased,
wiki_id)
values (%(filename)s,
(select file from files
where name=%(filename)s and
attached_to_pagename=%(oldpagename)s and
wiki_id=%(wiki_id)s
),
%(uploaded_time)s, %(uploaded_by)s,
%(uploaded_by_ip)s, %(newpagename)s,
%(newpagename_propercased)s, %(wiki_id)s
)""",
old_page_file_dict,
isWrite=True)
if is_image:
if old_page_file_dict.has_key('xsize'):
request.cursor.execute("""INSERT into imageInfo
(name, attached_to_pagename, xsize, ysize,
wiki_id)
values (%(filename)s, %(newpagename)s,
%(xsize)s, %(ysize)s, %(wiki_id)s) """,
old_page_file_dict,
isWrite=True)
else:
request.cursor.execute("""INSERT into oldFiles
(name, file, uploaded_time, uploaded_by, uploaded_by_ip,
attached_to_pagename, attached_to_pagename_propercased,
deleted_by, deleted_by_ip, deleted_time, wiki_id)
values (%(filename)s,
(SELECT file from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
(SELECT uploaded_time from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
(SELECT uploaded_by from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
(SELECT uploaded_by_ip from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
%(newpagename)s, %(newpagename_propercased)s,
%(userid)s, %(userip)s, %(timenow)s,
%(wiki_id)s)""",
old_page_file_dict,
isWrite=True)
# clear out cached version of image
if config.memcache:
request.mc.delete("files:%s,%s" %
(wikiutil.mc_quote(filename),
wikiutil.mc_quote(newpagename.lower())))
if is_image:
request.cursor.execute("""INSERT into oldImageInfo
(name, attached_to_pagename, xsize, ysize,
uploaded_time, wiki_id)
values
(%(filename)s, %(newpagename)s,
(SELECT xsize from imageInfo
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
(SELECT ysize from imageInfo
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
(SELECT uploaded_time from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s
),
%(wiki_id)s)""",
old_page_file_dict,
isWrite=True)
request.cursor.execute("""DELETE from thumbnails
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s""",
old_page_file_dict,
isWrite=True)
request.cursor.execute(
"""SELECT name from files
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s""", old_page_file_dict)
result = request.cursor.fetchone()
if result:
request.cursor.execute("""UPDATE files set
file=(select file from files
where name=%(filename)s and
attached_to_pagename=%(oldpagename)s and
wiki_id=%(wiki_id)s
),
uploaded_time=%(timenow)s, uploaded_by=%(userid)s,
uploaded_by_ip=%(userip)s
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s""",
old_page_file_dict,
isWrite=True)
if is_image and old_page_file_dict.has_key('xsize'):
request.cursor.execute("""UPDATE imageInfo set
xsize=%(xsize)s, ysize=%(ysize)s
where name=%(filename)s and
attached_to_pagename=%(newpagename)s and
wiki_id=%(wiki_id)s""",
old_page_file_dict,
isWrite=True)
else:
request.cursor.execute("""INSERT into files
(name, file, uploaded_time, uploaded_by,
uploaded_by_ip, xsize, ysize, attached_to_pagename,
attached_to_pagename_propercased, wiki_id)
values
(%(filename)s,
(select file from files
where name=%(filename)s and
attached_to_pagename=%(oldpagename)s and
wiki_id=%(wiki_id)s
),
%(uploaded_time)s, %(uploaded_by)s,
%(uploaded_by_ip)s, %(xsize)s, %(ysize)s,
%(newpagename)s, %(newpagename_propercased)s,
%(wiki_id)s)""",
old_page_file_dict,
isWrite=True)
if is_image and old_page_file_dict.has_key('xsize'):
request.cursor.execute("""INSERT into imageInfo
(name, attached_to_pagename, xsize, ysize,
wiki_id) values
(%(filename)s, %(newpagename)s, %(xsize)s,
%(ysize)s, %(wiki_id)s)""",
old_page_file_dict,
isWrite=True)
def execute(pagename, request):
_ = request.getText
actname = __name__.split('.')[-1]
page = PageEditor(pagename, request)
pagetext = page.get_raw_body()
msg = ''
# be extra paranoid in dangerous actions
if (actname in config.excluded_actions or not request.user.may.edit(page)
or not request.user.may.delete(page)):
msg = _('You are not allowed to rename pages in this wiki!')
# check whether page exists at all
elif not page.exists():
msg = _('This page is already deleted or was never created!')
# check whether the user clicked the delete button
elif (request.form.has_key('button')
and request.form.has_key('newpagename')
and request.form.has_key('ticket')):
# check whether this is a valid renaming request (make outside
# attacks harder by requiring two full HTTP transactions)
if not _checkTicket(request.form['ticket'][0]):
msg = _('Please use the interactive user '
'interface to rename pages!')
else:
renamecomment = request.form.get('comment', [''])[0]
# strip to ensure naming consistency
newpagename = request.form.get('newpagename')[0].strip()
if newpagename == pagename:
return Page(pagename, request).send_page(
msg="You can't rename a page to the name it already has!")
try:
newpage = PageEditor(newpagename, request)
except Page.ExcessiveLength, msg:
return Page(pagename, request).send_page(msg=msg)
if len(renamecomment) > wikiaction.MAX_COMMENT_LENGTH:
msg = _('Comments must be less than %s characters long.' %
wikiaction.MAX_COMMENT_LENGTH)
elif len(newpagename) > MAX_PAGENAME_LENGTH:
msg = _('Page names must be less than %s characters long.' %
MAX_PAGENAME_LENGTH)
# check whether a page with the new name already exists
elif (newpage.exists()
and not (newpagename.lower() == pagename.lower())):
msg = _('A page with the name "%s" already exists!') % (
newpagename)
elif not wikiaction.isValidPageName(newpagename):
msg = _('Invalid pagename: Only the characters A-Z, a-z, 0-9, '
'"$", "&", ",", ".", "!", "\'", ":", ";", " ", "/", '
'"-", "(", ")" are allowed in page names.')
# we actually do a rename!
else:
if renamecomment: renamecomment = " (" + renamecomment + ")"
if newpagename.lower() != pagename.lower():
page.saveText("#redirect %s" % newpagename,
'0',
comment='Renamed to "%s"' % newpagename,
action='RENAME',
force_save=True)
# copy images over
copy_files(pagename, newpagename, request)
newpage.saveText(pagetext,
'0',
comment='Renamed from "%s"%s' %
(pagename, renamecomment),
action="RENAME",
proper_name=newpagename)
msg = _('Page "%s" was successfully renamed to "%s"!') % (
pagename, newpagename)
if newpagename.lower() != pagename.lower():
# check favorites because the redirect will
# process before the bookmarks get updated
if request.user.valid:
request.user.checkFavorites(page)
request.http_redirect(
'%s/%s?action=show&redirect=%s' %
(request.getScriptname(),
wikiutil.quoteWikiname(newpagename),
urllib.quote_plus(pagename.encode(config.charset),
'')))
request.req_cache['pagenames'][(
newpagename.lower(),
request.config.wiki_name)] = newpagename
# we clear so the new page name appears
caching.CacheEntry(newpagename.lower(), request).clear()
return
else:
request.req_cache['pagenames'][(
newpagename.lower(),
request.config.wiki_name)] = newpagename
# we clear so the new page name appears
caching.CacheEntry(newpagename.lower(), request).clear()
return newpage.send_page(msg)
def saveText(self, newtext, datestamp, **kw):
"""
Save new text for a page.
@param newtext: text to save for this page
@param datestamp: ...
@keyword stripspaces: strip whitespace from line ends (default: 0)
@keyword notify: send email notice tp subscribers (default: 0)
@keyword comment: comment field (when preview is true)
@keyword action: action for log (default: SAVE)
@keyword proper_name: properly-cased pagename (for renames)
@keyword ignore_edit_conflicts: force a save regardless of status
(boolean)
@keyword force_save: ignore "page content the same" error
@rtype: string
@return: error msg
"""
self.page_name = self.page_name.strip() # to ensure consistency
_ = self._
newtext = self._normalize_text(newtext, **kw)
# for inline editing we want things to be as smooth as we can
no_save_msg = False
if (self.request.form.has_key('no_save_msg')
and self.request.form['no_save_msg'][0]):
no_save_msg = True
msg = ""
merged_changes = False
ignore_edit_conflicts = kw.get('ignore_edit_conflicts', False)
if not self.request.user.may.save(self, newtext, datestamp, **kw):
msg = _('You are not allowed to edit this page!')
raise self.AccessDenied, msg
elif not newtext.strip():
msg = _('You cannot save empty pages.')
raise self.EmptyPage, msg
elif (not ignore_edit_conflicts and datestamp != '0'
and (datestamp < self.mtime()) and self.exists()):
from Sycamore.util import diff3
savetext = newtext
original_text = Page(self.page_name,
self.request,
prev_date=datestamp).get_raw_body()
saved_text = self.get_raw_body()
verynewtext, had_conflict = diff3.text_merge(
original_text,
saved_text,
savetext,
marker1='----- /!\ Edit conflict! Your version: -----\n',
marker2='----- /!\ Edit conflict! Other version: -----\n',
marker3='----- /!\ End of edit conflict -----\n')
msg = _("Someone else changed this page while you were editing.")
if (had_conflict and self.request.user.valid
and (self.request.user.id == self.last_edit_info()[1])):
# user pressed back button or did something weird
had_conflict = False
msg = None
else:
# we did some sort of merging or we had a conflict,
# so let them know
if had_conflict:
raise self.EditConflict, (msg, verynewtext)
merged_changes = True
msg = _("""%s Your changes were successfully merged! """ % msg)
newtext = verynewtext
elif (newtext == self.get_raw_body()
and not self._rename_lowercase_condition()
and kw.get('action') != 'SAVE/REVERT'
and not kw.get('force_save')):
# check to see if they're saving the page with the same content
# it had before
msg = _('You did not change the page content, not saved!')
raise self.Unchanged, msg
elif (config.max_page_size and len(newtext.encode(config.charset)) >
(config.max_page_size * 1024)):
msg = _('This page is too big! Pages can be, at most, %sK. '
'Consider splitting the page up into multiple pages '
'instead!' % config.max_page_size)
raise self.TooBig, msg
# save only if no error occured (msg is empty)
if not msg or merged_changes:
# set success msg
if not merged_changes and not no_save_msg:
msg = _("Thank you for your changes. "
"Your attention to detail is appreciated. ")
# determine action for edit logging
action = kw.get('action', 'SAVE')
if action == 'SAVE' and not self.exists():
action = 'SAVENEW'
# write the page file
mtime = self._write_to_db(newtext, action, kw.get('comment', ''),
self.request.remote_addr,
kw.get('proper_name', None))
# deal with the case of macros / other items that change state by
# /not/ being in the page
wikiutil.macro_delete_checks(self)
# we'll try to change the stats early-on
if self.request.user.name:
self.userStatAdd(self.request.user, action, self.page_name)
# add the page to the search index or update its index
if action != 'DELETE':
search.add_to_index(self)
# note the change in recent changes. this explicit call is needed
# because of the way we cache our change information
caching.updateRecentChanges(self)
return msg
def execute(pagename, request):
from Sycamore.PageEditor import PageEditor
_ = request.getText
actname = __name__.split('.')[-1]
page = Page(pagename, request)
permanent = False
showrc = True
if not request.user.may.edit(page):
return page.send_page(
msg = _('You are not allowed to revert this page!'))
# check whether the user clicked the delete button
if request.form.has_key('button') and request.form.has_key('ticket'):
# check whether this is a valid deletion request (make outside
# attacks harder by requiring two full HTTP transactions)
if not _checkTicket(request.form['ticket'][0]):
return page.send_page(
msg = _('Please use the interactive user interface to '
'revert pages!'))
# revert the page
if request.form.has_key('version'):
version = int(request.form['version'][0])
oldpg = Page(pagename, request, version=version)
date = oldpg.prev_date
if request.form.has_key('comment'):
entered_comment = request.form['comment'][0]
else:
entered_comment = ''
if len(entered_comment) > wikiaction.MAX_COMMENT_LENGTH:
return page.send_page(msg = _(
'Comments must be less than %s characters long.' %
wikiaction.MAX_COMMENT_LENGTH))
else:
comment = 'v%s' % str(version)
comment = "%sc%s" % (comment, entered_comment)
else:
return
if (request.form.has_key('permanent') and
request.form['permanent'][0] and request.user.may.admin(page)):
permanent = True
if (request.form.has_key('noshowrc') and
request.form['noshowrc'][0]):
showrc = False
pg = PageEditor(pagename, request)
savemsg = revert_to_page(oldpg, request, pg, comment=comment,
permanent=permanent, showrc=showrc)
return pg.send_page(msg=savemsg,
force_regenerate_content=(permanent and not
showrc))
# get version
if request.form.has_key('version'):
version = request.form['version'][0]
else:
return page.send_page(msg= _(
'Please use the interactive user interface to revert pages!'))
oldpg = Page(pagename, request, version=version)
# send revert form
url = page.url()
ticket = _createTicket()
button = _('Revert')
comment_label = _("Reason for the revert:")
if request.user.may.admin(page):
admin_label = (
'<p>Permanently remove newer versions: '
'<input id="noshowrctoggle" type="checkbox" name="permanent" '
'value="1"><span id="noshowrc">'
"Don't log on Recent Changes: "
'<input type="checkbox" name="noshowrc" value="1"></span></p>\n'
'<script type="text/javascript">\n'
"document.getElementById('noshowrc').style.visibility = "
"'hidden';\n"
"document.getElementById('noshowrc').style.paddingLeft = "
"'1em';\n"
"document.getElementById('noshowrctoggle').onclick = "
"function () {\n"
"document.getElementById('noshowrc').style.visibility = "
"document.getElementById('noshowrctoggle').checked ? "
"'visible' : 'hidden'; \n"
"}\n"
"</script>\n"
)
else:
admin_label = ''
formhtml = (
'<form method="GET" action="%(url)s">'
'<input type="hidden" name="action" value="%(actname)s">'
'<input type="hidden" name="ticket" value="%(ticket)s">'
'<input type="hidden" name="version" value="%(version)s">'
'<p>'
'%(comment_label)s'
'</p>'
'<input type="text" name="comment" size="60" maxlength="80">'
'<input type="submit" name="button" value="%(button)s">'
'%(admin_label)s'
'</form>' % {
'url': url,
'actname': actname,
'ticket': ticket,
'button': button,
'comment_label': comment_label,
'version': version,
'admin_label': admin_label,
})
return oldpg.send_page(msg=formhtml)
