def pp_get_pad(context, nodelist, *args, **kwargs):
"""
Retrieves the current image for this object id.
"""
context.push()
namespace = get_namespace(context)
obj = kwargs.get('object', None)
myPad = EtherpadLiteClient(ETHERPAD_API, 'http://notes.occupy.net/api')
try:
if ETHERPAD_API != None:
#Change the text of the etherpad
try:
text = myPad.getHtml(str(obj.pk))
except:
myPad.createPad(str(obj.pk), '')
text = myPad.getHtml(str(obj.pk))
namespace['text'] = text['html']
else:
namespace['text'] = '<p>No API Key</p>'
except:
namespace['text'] = '<p>Looks like the Occupy.net Etherpad server is down... Thanks for your patience</p>'
output = nodelist.render(context)
context.pop()
return output
def post(self):
user = users.get_current_user()
if user:
try:
uploaded_file = (self.get_uploads('file'))[0]
except:
uploaded_file = None
origin = self.request.get('create_from')
if origin == 'textarea':
pad_text = self.request.get('pad_text').strip()
else:
if uploaded_file is None:
pad_text = ''
else:
blob_reader = blobstore.BlobReader(uploaded_file)
document = opendocx(blob_reader)
pad_text = doc_to_text(document)
pad_name = self.request.get('padName')
myPad = EtherpadLiteClient()
pad_id = id_generator()
pad = myPad.createPad(padID = pad_id, text=pad_text)
pad = Pad(owner = user.email(), name=pad_name, pad_id = pad_id, master='')
pad.put()
else:
self.error(404)
if uploaded_file:
uploaded_file.delete()
self.redirect('/mypads')
def create_article_ether_group(group_id, article):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
group = EtherGroup.objects.get(group=group_id)
result = epclient.createGroupPad(group.group_ether_id, article.id)
EtherArticle.objects.create(article=article,
article_ether_id=result['padID'])
return result['padID']
def create_article_ether_community(community_id, article):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
community = EtherCommunity.objects.get(community=community_id)
result = epclient.createGroupPad(community.community_ether_id, article.id)
EtherArticle.objects.create(article=article,
article_ether_id=result['padID'])
return result['padID']
def EtherMap(self):
epclient = EtherpadLiteClient(self.server.apikey, self.server.apiurl)
result = epclient.createAuthorIfNotExistsFor(
self.user.id.__str__(),
name=self.__unicode__()
)
self.authorID = result['authorID']
return result
def create_session_group(request, group_id):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
ether_group = EtherGroup.objects.get(group=group_id)
ether_group = str(ether_group.group_ether_id)
ether_user = EtherUser.objects.get(user=request.user)
ether_user = str(ether_user.user_ether_id)
validUntil = int(time()) + 28800
result = epclient.createSession(ether_group, ether_user, validUntil)
return result['sessionID']
def create_session_community(request, community_id):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
ether_com = EtherCommunity.objects.get(community=community_id)
ether_com = str(ether_com.community_ether_id)
ether_user = EtherUser.objects.get(user=request.user)
ether_user = str(ether_user.user_ether_id)
validUntil = int(time())+28800
result = epclient.createSession(ether_com, ether_user, validUntil)
return result['sessionID']
def post(self):
padname = self.request.form['name'].strip()
padMgr = EtherpadLiteClient(self.config.settings.pad_api_key, self.config.settings.pad_api_url)
if padname!="":
try:
padMgr.deletePad(padname)
except ValueError, e:
self.flash(u"Fehler: %s" %e, css_class="error")
else:
self.flash(u"Das Pad '%s' wurde erfolgreich gelöscht!" %padname, css_class="success")
def pad(request, pk=None, slug=None):
"""Create and session and display an embedded pad
"""
# Initialize some needed values
if slug:
pad = get_object_or_404(Pad, name=slug)
else:
pad = get_object_or_404(Pad, pk=pk)
padLink = pad.server.url + 'p/' + pad.group.groupID + '$' + \
urllib.quote_plus(pad.name)
server = urlparse(pad.server.url)
author = PadAuthor.objects.get(user=request.user)
if author not in pad.group.authors.all():
response = render_to_response(
'pad.html',
{
'pad': pad,
'link': padLink,
'server': server,
'uname': author.user.__unicode__(),
'error': _('You are not allowed to view or edit this pad')
},
context_instance=RequestContext(request)
)
return response
# Create the session on the etherpad-lite side
expires = datetime.datetime.utcnow() + datetime.timedelta(
seconds=config.SESSION_LENGTH
)
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
try:
result = epclient.createSession(
pad.group.groupID,
author.authorID,
time.mktime(expires.timetuple()).__str__()
)
except Exception, e:
response = render_to_response(
'pad.html',
{
'pad': pad,
'link': padLink,
'server': server,
'uname': author.user.__unicode__(),
'error': _('etherpad-lite session request returned:') +
' "' + e.reason + '"'
},
context_instance=RequestContext(request)
)
return response
def handle(self, *args, **options):
for pad in Pad.objects.all():
padID = pad.group.groupID + '$' + urllib.quote_plus(pad.name.replace('::', '_'))
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
text = epclient.getText(padID)['text']
backup_file_path = os.path.join(BACKUP_DIR, pad.display_slug)
with open(backup_file_path.encode('utf-8'), 'w') as f:
f.write(text.encode('utf-8'))
def css_slide(request):
try:
pad = Pad.objects.get(display_slug='slidy.css')
padID = pad.group.groupID + '$' + urllib.quote_plus(pad.name.replace('::', '_'))
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
return HttpResponse(epclient.getText(padID)['text'], mimetype="text/css")
except:
# If there is no pad called "css", loads a default css file
f = open('relearn/static/css/slidy.css', 'r')
css = f.read()
f.close()
return HttpResponse(css, mimetype="text/css")
class Etherpad:
def __init__(self):
self.epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
def create_ether_blog(self, blog):
groupid = self.epclient.createGroupIfNotExistsFor(str(blog.uuid))
padid = self.epclient.createGroupPad(groupid['groupID'], blog.pk)
blog = EtherBlog.objects.create(blog=blog,
etherid=padid['padID'],
groupid=groupid['groupID'])
return blog
def create_ether_user(self, user):
result = self.epclient.createAuthorIfNotExistsFor(
user.id, user.username)
user = EtherUser.objects.create(user=user,
user_ether_id=result['authorID'])
return user
def create_session_group(self, request, groupid):
ethergroup = str(groupid)
try:
etheruser = EtherUser.objects.get(user=request.user)
except Exception:
etheruser = self.create_ether_user(request.user)
etheruser = str(etheruser.user_ether_id)
validUntil = int(time()) + 28800
result = self.epclient.createSession(ethergroup, etheruser, validUntil)
return result['sessionID']
def getHTML(self, blog):
blog = EtherBlog.objects.get(blog=blog)
result = self.epclient.getHtml(blog.etherid)
return result['html']
def getText(self, blog):
blog = EtherBlog.objects.get(blog=blog)
result = self.epclient.getText(blog.etherid)
return result['text']
def deletePad(self, blog):
article = EtherBlog.objects.get(blog=blog)
self.epclient.deletePad(blog.etherid)
return
def get_pad_usercount(self, blog):
count = self.epclient.padUsersCount(blog.etherid)
return count['padUsersCount']
def get_read_only_padid(self, blog):
readonly = self.epclient.getReadOnlyID(blog.etherid)
return readonly['readOnlyID']
def pad_generate_url(self, cr, uid, context=None):
company = self.pool.get('res.users').browse(cr, SUPERUSER_ID, uid, context=context).company_id
pad = {
"server" : company.pad_server,
"key" : company.pad_key,
}
# make sure pad server in the form of http://hostname
if not pad["server"]:
return pad
if not pad["server"].startswith('http'):
pad["server"] = 'http://' + pad["server"]
pad["server"] = pad["server"].rstrip('/')
# generate a salt
s = string.ascii_uppercase + string.digits
salt = ''.join([s[random.randint(0, len(s) - 1)] for i in range(10)])
#path
# etherpad hardcodes pad id length limit to 50
path = '-%s-%s' % (self._name, salt)
path = '%s%s' % (cr.dbname.replace('_','-')[0:50 - len(path)], path)
# contruct the url
url = '%s/p/%s' % (pad["server"], path)
#if create with content
if "field_name" in context and "model" in context and "object_id" in context:
myPad = EtherpadLiteClient( pad["key"], pad["server"]+'/api')
try:
myPad.createPad(path)
except urllib2.URLError:
raise osv.except_osv(_("Error"), _("Pad creation failed, \
either there is a problem with your pad server URL or with your connection."))
#get attr on the field model
model = self.pool[context["model"]]
field = model._fields[context['field_name']]
real_field = field.pad_content_field
#get content of the real field
for record in model.browse(cr, uid, [context["object_id"]]):
if record[real_field]:
myPad.setText(path, (html2plaintext(record[real_field]).encode('utf-8')))
#Etherpad for html not functional
#myPad.setHTML(path, record[real_field])
return {
"server": pad["server"],
"path": path,
"url": url,
}
def pad(request, pk):
"""Create and session and display an embedded pad
"""
# Initialize some needed values
pad = get_object_or_404(Pad, pk=pk)
padLink = pad.server.url + 'p/' + pad.group.groupID + '$' + \
urllib.quote_plus(pad.name)
server = urlparse(pad.server.url)
author = PadAuthor.objects.get(user=request.user)
if author not in pad.group.authors.all():
response = render_to_response(
'etherpad-lite/pad.html', {
'pad': pad,
'link': padLink,
'server': server,
'uname': author.user.__unicode__(),
'error': _('You are not allowed to view or edit this pad')
},
context_instance=RequestContext(request))
return response
# Create the session on the etherpad-lite side
expires = datetime.datetime.utcnow() + datetime.timedelta(
seconds=config.SESSION_LENGTH)
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
try:
result = epclient.createSession(
pad.group.groupID, author.authorID,
time.mktime(expires.timetuple()).__str__())
except Exception, e:
response = render_to_response('etherpad-lite/pad.html', {
'pad':
pad,
'link':
padLink,
'server':
server,
'uname':
author.user.__unicode__(),
'error':
_('etherpad-lite session request returned:') + ' "' + e.reason +
'"'
},
context_instance=RequestContext(request))
return response
def pad_generate_url(self, cr, uid, context=None):
company = self.pool.get("res.users").browse(cr, uid, uid, context=context).company_id
pad = {"server": company.pad_server, "key": company.pad_key}
# make sure pad server in the form of http://hostname
if not pad["server"]:
return pad
if not pad["server"].startswith("http"):
pad["server"] = "http://" + pad["server"]
pad["server"] = pad["server"].rstrip("/")
# generate a salt
s = string.ascii_uppercase + string.digits
salt = "".join([s[random.randint(0, len(s) - 1)] for i in range(10)])
# path
path = "%s-%s-%s" % (cr.dbname.replace("_", "-"), self._name, salt)
# contruct the url
url = "%s/p/%s" % (pad["server"], path)
# if create with content
if "field_name" in context and "model" in context and "object_id" in context:
myPad = EtherpadLiteClient(pad["key"], pad["server"] + "/api")
try:
myPad.createPad(path)
except urllib2.URLError:
raise osv.except_osv(
_("Error"),
_(
"Pad creation failed, \
either there is a problem with your pad server URL or with your connection."
),
)
# get attr on the field model
model = self.pool[context["model"]]
field = model._all_columns[context["field_name"]]
real_field = field.column.pad_content_field
# get content of the real field
for record in model.browse(cr, uid, [context["object_id"]]):
if record[real_field]:
myPad.setText(path, html2plaintext(record[real_field]))
# Etherpad for html not functional
# myPad.setHTML(path, record[real_field])
return {"server": pad["server"], "path": path, "url": url}
def pad_read(request, pk=None, slug=None):
"""Read only pad
"""
# Initialize some needed values
if slug:
pad = get_object_or_404(Pad, name=slug)
else:
pad = get_object_or_404(Pad, pk=pk)
padID = pad.group.groupID + '$' + urllib.quote_plus(pad.name.replace('::', '_'))
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
tpl_params = { 'pad' : pad, 'text' : epclient.getHtml(padID)['html'], 'mode' : 'read' }
# or tpl_params = { 'text' : epclient.getText(padID)['text'] }, and do processing ourselves—
# we need to figure out if Etherpad’s html output suffices for our purposes
return render_to_response("pad-read.html", tpl_params, context_instance = RequestContext(request))
def pad_generate_url(self, cr, uid, context=None):
company = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id;
pad = {
"server" : company.pad_server,
"key" : company.pad_key or "4DxmsNIbnQUVQMW9S9tx2oLOSjFdrx1l",
}
# make sure pad server in the form of http://hostname
if not pad["server"]:
return ''
if not pad["server"].startswith('http'):
pad["server"] = 'http://' + pad["server"]
pad["server"] = pad["server"].rstrip('/')
# generate a salt
s = string.ascii_uppercase + string.digits
salt = ''.join([s[random.randint(0, len(s) - 1)] for i in range(10)])
#path
path = '%s-%s-%s' % (cr.dbname.replace('_','-'), self._name, salt)
# contruct the url
url = '%s/p/%s' % (pad["server"], path)
#if create with content
if "field_name" in context and "model" in context and "object_id" in context:
myPad = EtherpadLiteClient( pad["key"], pad["server"]+'/api')
myPad.createPad(path)
#get attr on the field model
model = self.pool.get(context["model"])
field = model._all_columns[context['field_name']]
real_field = field.column.pad_content_field
#get content of the real field
for record in model.browse(cr, uid, [context["object_id"]]):
if record[real_field]:
myPad.setText(path, html2plaintext(record[real_field]))
#Etherpad for html not functional
#myPad.setHTML(path, record[real_field])
return {
"server": pad["server"],
"path": path,
"url": url,
}
def setup(bot):
global etherpad
# bot.memory["rythm"] = int(bot.config.plenum.rythm)
# date = [int(i) for i in bot.config.plenum.startdate.split(".")[::-1]]
bot.memory["nextplenum"] = nextmeeting()
bot.memory["etherpad"] = bot.config.plenum.etherpadurl
bot.memory["apikey"] = bot.config.plenum.apikey
bot.memory["padid"] = "ffda-" + bot.memory["nextplenum"].strftime("%Y%m%d")
updatetemplate(bot, bot.config.plenum.template)
etherpad = EtherpadLiteClient(bot.memory["apikey"],
bot.memory["etherpad"] + "/api")
padsetup(bot)
def pp_get_pad(context, nodelist, *args, **kwargs):
"""
Retrieves the current image for this object id.
"""
context.push()
namespace = get_namespace(context)
obj = kwargs.get('object', None)
myPad = EtherpadLiteClient(ETHERPAD_API, 'http://notes.occupy.net/api')
try:
if ETHERPAD_API != None:
#Change the text of the etherpad
try:
text = myPad.getHtml(str(obj.pk))
except:
myPad.createPad(str(obj.pk), '')
text = myPad.getHtml(str(obj.pk))
namespace['text'] = text['html']
else:
namespace['text'] = '<p>No API Key</p>'
except:
namespace['text'] = '<p>Looks like the Occupy.net Etherpad server is down... Thanks for your patience</p>'
output = nodelist.render(context)
context.pop()
return output
def pad_generate_url(self, cr, uid, context=None):
company = self.pool.get('res.users').browse(cr,
SUPERUSER_ID,
uid,
context=context).company_id
pad = {
"server": company.pad_server,
"key": company.pad_key,
}
# make sure pad server in the form of http://hostname
if not pad["server"]:
return pad
if not pad["server"].startswith('http'):
pad["server"] = 'http://' + pad["server"]
pad["server"] = pad["server"].rstrip('/')
# generate a salt
s = string.ascii_uppercase + string.digits
salt = ''.join([
s[random.SystemRandom().randint(0,
len(s) - 1)] for i in range(10)
])
#path
# etherpad hardcodes pad id length limit to 50
path = '-%s-%s' % (self._name, salt)
path = '%s%s' % (cr.dbname.replace('_', '-')[0:50 - len(path)], path)
# contruct the url
url = '%s/p/%s' % (pad["server"], path)
#if create with content
if "field_name" in context and "model" in context and "object_id" in context:
myPad = EtherpadLiteClient(pad["key"], pad["server"] + '/api')
try:
myPad.createPad(path)
except urllib2.URLError:
raise UserError(
_("Pad creation failed, either there is a problem with your pad server URL or with your connection."
))
#get attr on the field model
model = self.pool[context["model"]]
field = model._fields[context['field_name']]
real_field = field.pad_content_field
#get content of the real field
for record in model.browse(cr, uid, [context["object_id"]]):
if record[real_field]:
myPad.setText(
path,
(html2plaintext(record[real_field]).encode('utf-8')))
#Etherpad for html not functional
#myPad.setHTML(path, record[real_field])
return {
"server": pad["server"],
"path": path,
"url": url,
}
def __init__(self, etherpadKey, asrChannel, redisHost, mongodbHost = '127.0.1.1:27017'):
# MongoDB
self.myclient = pymongo.MongoClient('mongodb://' + mongodbHost)
self.mydb = self.myclient['meteor']['captions']
# REDIS
red = redis.Redis(host=redisHost, port=6379, password='')
self.pubsub = red.pubsub(ignore_subscribe_messages=True)
self.pubsub.subscribe(asrChannel, 'from-akka-apps-redis-channel', 'to-voice-conf-redis-channel')
# Etherpad
self.etherpadKey= etherpadKey
self.myPad = EtherpadLiteClient(self.etherpadKey)
self.meetings = {}
self.lastTimestamp = 0
self.message = {}
self.the_loop()
def pad_generate_url(self, cr, uid, context=None):
company = self.pool.get('res.users').browse(cr,
uid,
uid,
context=context).company_id
pad = {
"server": company.pad_server,
"key": company.pad_key,
}
# make sure pad server in the form of http://hostname
if not pad["server"]:
return pad
if not pad["server"].startswith('http'):
pad["server"] = 'http://' + pad["server"]
pad["server"] = pad["server"].rstrip('/')
# generate a salt
s = string.ascii_uppercase + string.digits
salt = ''.join([s[random.randint(0, len(s) - 1)] for i in range(10)])
#path
path = '%s-%s-%s' % (cr.dbname.replace('_', '-'), self._name, salt)
# contruct the url
url = '%s/p/%s' % (pad["server"], path)
#if create with content
if "field_name" in context and "model" in context and "object_id" in context:
myPad = EtherpadLiteClient(pad["key"], pad["server"] + '/api')
myPad.createPad(path)
#get attr on the field model
model = self.pool[context["model"]]
field = model._all_columns[context['field_name']]
real_field = field.column.pad_content_field
#get content of the real field
for record in model.browse(cr, uid, [context["object_id"]]):
if record[real_field]:
myPad.setText(path, html2plaintext(record[real_field]))
#Etherpad for html not functional
#myPad.setHTML(path, record[real_field])
return {
"server": pad["server"],
"path": path,
"url": url,
}
def getText(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) result = epclient.getText(article.id) return result['text']
#!/usr/local/bin/python
pdflatex = "/usr/local/texlive/2011/bin/amd64-freebsd/pdflatex"
import cgi
import cgitb; cgitb.enable() # for troubleshooting
import os
import tempfile
import codecs
from py_etherpad import EtherpadLiteClient
myPad = EtherpadLiteClient('yourapitoken','http://etherpad.install.tld/api')
#get the text of the etherpad
padText = myPad.getText('testPad')
tmpDir= tempfile.mkdtemp()
# Clean up the directory yourself
# os.removedirs(tmpDir)
file = codecs.open("%s/pad.tex" %(tmpDir), "w", "utf-8")
#print "%s/pad.tex" %(tmpDir)
file.write(padText['text'])
file.close()
#cmdstring = "some_other_script.py %s %s" % (argument1 argument2)
cmdstring = "%s -output-directory=%s -halt-on-error %s/pad.tex > /dev/null" %(pdflatex,tmpDir,tmpDir)
os.system(cmdstring)
cmdstring = "cp %s/pad.pdf ." % (tmpDir)
os.system("rm pad.pdf")
os.system(cmdstring)
os.system("rm %s/pad*" % (tmpDir))
def deletePad(article):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
article = EtherArticle.objects.get(article=article)
epclient.deletePad(article.article_ether_id)
def getText(article):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
article = EtherArticle.objects.get(article=article)
result = epclient.getText(article.article_ether_id)
return result['text']
def pad(request, pk):
"""Create and session and display an embedded pad
"""
# Initialize some needed values
pad = get_object_or_404(Pad, pk=pk)
padLink = pad.server.url + 'p/' + pad.group.groupID + '$' + \
urllib.parse.quote_plus(pad.name)
server = urlparse(pad.server.url)
author = PadAuthor.objects.get(user=request.user)
# if author not in pad.group.authors.all():
# return render(
# request,
# 'pad.html',
# {
# 'pad': pad,
# 'link': padLink,
# 'server': server,
# 'uname': author.user.__unicode__(),
# 'error': _('You are not allowed to view or edit this pad')
# }
# )
# Create the session on the etherpad-lite side
expires = datetime.datetime.utcnow() + datetime.timedelta(
seconds=config.SESSION_LENGTH)
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
try:
result = epclient.createSession(
pad.group.groupID, author.authorID,
time.mktime(expires.timetuple()).__str__())
except Exception as e:
return render(
request, 'pad.html', {
'pad':
pad,
'link':
padLink,
'server':
server,
'uname':
author.user.__str__(),
'error':
_('etherpad-lite session request returned:') + ' "' + str(e) +
'"'
})
response = render(
request, 'pad.html', {
'pad': pad,
'link': padLink,
'server': server,
'uname': author.user.__str__(),
'error': False
})
# Delete the existing session first
if ('padSessionID' in request.COOKIES):
epclient.deleteSession(request.COOKIES['sessionID'])
response.delete_cookie('sessionID', server.hostname)
response.delete_cookie('padSessionID')
# Set the new session cookie for both the server and the local site
response.set_cookie(key='sessionID',
value=result['sessionID'],
expires=expires,
httponly=False)
response.set_cookie(key='padSessionID',
value=result['sessionID'],
expires=expires,
httponly=False)
# request.session['sessionID']= result['sessionID']
# request.session['padSessionID']= result['sessionID']
# request.set_expiry(expires)
return response
def epclient(self):
return EtherpadLiteClient(self.server.apikey, self.server.apiurl)
def deletePad(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) epclient.deletePad(article.id)
def create_group_ether(group):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
group_id = 'group' + str(group.id)
result = epclient.createGroupIfNotExistsFor(group_id)
EtherGroup.objects.create(group=group, group_ether_id=result['groupID'])
return
def get_read_only_padid(article_id):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
padid = get_pad_id(article_id)
readonlyid = epclient.getReadOnlyID(padid)
return readonlyid['readOnlyID']
def get_pad_usercount(article_id):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
padid = get_pad_id(article_id)
count = epclient.padUsersCount(padid)
return count['padUsersCount']
#!/usr/local/bin/python
pdflatex = "/usr/local/texlive/2011/bin/amd64-freebsd/pdflatex"
import cgi
import cgitb
cgitb.enable() # for troubleshooting
import os
import tempfile
import codecs
from py_etherpad import EtherpadLiteClient
myPad = EtherpadLiteClient('yourapitoken', 'http://etherpad.install.tld/api')
#get the text of the etherpad
padText = myPad.getText('testPad')
tmpDir = tempfile.mkdtemp()
# Clean up the directory yourself
# os.removedirs(tmpDir)
file = codecs.open("%s/pad.tex" % (tmpDir), "w", "utf-8")
#print "%s/pad.tex" %(tmpDir)
file.write(padText['text'])
file.close()
#cmdstring = "some_other_script.py %s %s" % (argument1 argument2)
cmdstring = "%s -output-directory=%s -halt-on-error %s/pad.tex > /dev/null" % (
pdflatex, tmpDir, tmpDir)
os.system(cmdstring)
def __init__(self):
self.epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
def pad_read(request, mode="r", slug=None):
"""Read only pad
"""
# FIND OUT WHERE WE ARE,
# then get previous and next
try:
articles = json.load(open(os.path.join(BACKUP_DIR, 'index.json')))
except IOError:
articles = []
SITE = get_current_site(request)
href = "http://%s" % SITE.domain + request.path
prev = None
next = None
for i, article in enumerate(articles):
if article['href'] == href:
if i != 0: # The first is the most recent article, there is no newer
next = articles[i-1]
if i != len(articles) - 1:
prev = articles[i+1]
# Initialize some needed values
pad = get_object_or_404(Pad, display_slug=slug)
padID = pad.group.groupID + '$' + urllib.quote_plus(pad.name.replace('::', '_'))
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
# Etherpad gives us authorIDs in the form ['a.5hBzfuNdqX6gQhgz', 'a.tLCCEnNVJ5aXkyVI']
# We link them to the Django users DjangoEtherpadLite created for us
authorIDs = epclient.listAuthorsOfPad(padID)['authorIDs']
authors = PadAuthor.objects.filter(authorID__in=authorIDs)
authorship_authors = []
for author in authors:
authorship_authors.append({ 'name' : author.user.first_name if author.user.first_name else author.user.username,
'class' : 'author' + author.authorID.replace('.','_') })
authorship_authors_json = json.dumps(authorship_authors, indent=2)
name, extension = os.path.splitext(slug)
meta = {}
if not extension:
# Etherpad has a quasi-WYSIWYG functionality.
# Though is not alwasy dependable
text = epclient.getHtml(padID)['html']
# Quick and dirty hack to allow HTML in pads
text = unescape(text)
else:
# If a pad is named something.css, something.html, something.md etcetera,
# we don’t want Etherpads automatically generated HTML, we want plain text.
text = epclient.getText(padID)['text']
if extension in ['.md', '.markdown']:
md = markdown.Markdown(extensions=['extra', 'meta', 'headerid(level=2)', 'attr_list', 'figcaption'])
text = md.convert(text)
try:
meta = md.Meta
except AttributeError: # Edge-case: this happens when the pad is completely empty
meta = None
# Convert the {% include %} tags into a form easily digestible by jquery
# {% include "example.html" %} -> <a id="include-example.html" class="include" href="/r/include-example.html">include-example.html</a>
def ret(matchobj):
return '<a id="include-%s" class="include pad-%s" href="%s">%s</a>' % (slugify(matchobj.group(1)), slugify(matchobj.group(1)), reverse('pad-read', args=("r", matchobj.group(1)) ), matchobj.group(1))
text = include_regex.sub(ret, text)
# Create namespaces from the url of the pad
# 'pedagogy::methodology' -> ['pedagogy', 'methodology']
namespaces = [p.rstrip('-') for p in pad.display_slug.split('::')]
meta_list = []
# One needs to set the ‘Static’ metadata to ‘Public’ for the page to be accessible to outside visitors
if not meta or not 'status' in meta or not meta['status'][0] or not meta['status'][0].lower() in ['public']:
if not request.user.is_authenticated():
pass #raise PermissionDenied
if meta and len(meta.keys()) > 0:
# The human-readable date is parsed so we can sort all the articles
if 'date' in meta:
meta['date_iso'] = []
meta['date_parsed'] = []
for date in meta['date']:
date_parsed = dateutil.parser.parse(date)
# If there is no timezone we assume it is in Brussels:
if not date_parsed.tzinfo:
date_parsed = pytz.timezone('Europe/Brussels').localize(date_parsed)
meta['date_parsed'].append(date_parsed)
meta['date_iso'].append( date_parsed.isoformat() )
meta_list = list(meta.iteritems())
tpl_params = { 'pad' : pad,
'meta' : meta, # to access by hash, like meta.author
'meta_list' : meta_list, # to access all meta info in a (key, value) list
'text' : text,
'prev_page' : prev,
'next_page' : next,
'mode' : mode,
'namespaces' : namespaces,
'authorship_authors_json' : authorship_authors_json,
'authors' : authors }
if not request.user.is_authenticated():
request.session.set_test_cookie()
tpl_params['next'] = reverse('pad-write', args=(slug,) )
if mode == "r":
return render_to_response("pad-read.html", tpl_params, context_instance = RequestContext(request))
elif mode == "s":
return render_to_response("pad-slide.html", tpl_params, context_instance = RequestContext(request))
elif mode == "p":
return render_to_response("pad-print.html", tpl_params, context_instance = RequestContext(request))
def pad(request, pk):
"""Create and session and display an embedded pad
"""
# Initialize some needed values
pad = get_object_or_404(Pad, pk=pk)
server = urlparse(pad.server.url)
author = PadAuthor.objects.get(user=request.user)
if author not in pad.group.authors.all():
response = render_to_response(
'etherpad-lite/pad.html',
{
'pad': pad,
'link': pad.link,
'server': server,
'uname': author.user.__unicode__(),
'error': _('You are not allowed to view or edit this pad')
},
context_instance=RequestContext(request)
)
return response
# Create the session on the etherpad-lite side
expires = datetime.datetime.utcnow() + datetime.timedelta(
seconds=config.SESSION_LENGTH
)
epclient = EtherpadLiteClient(pad.server.apikey, pad.server.apiurl)
default_author_name_mapper = lambda user: user.__unicode__()
author_name_mapper = getattr(settings, 'ETHERPAD_AUTHOR_NAME_MAPPER', default_author_name_mapper)
default_etherpad_settings = {
"showControls": True,
"showChat": True,
"alwaysShowChat": False,
"showLineNumbers": False,
"useMonospaceFont": False,
"noColors": False,
"hideQRCode": True,
"rtl": False,
"userName": author_name_mapper(author.user).encode('utf-8'),
}
pad_settings = default_etherpad_settings
pad_settings.update(getattr(settings, 'ETHERPAD_SETTINGS', {}))
for key, value in pad_settings.items():
if value == True:
pad_settings[key] = 'true'
elif value == False:
pad_settings[key] = 'false'
try:
result = epclient.createSession(
pad.group.groupID,
author.authorID,
time.mktime(expires.timetuple()).__str__()
)
except Exception, e:
response = render_to_response(
'etherpad-lite/pad.html',
{
'pad': pad,
'link': pad.link,
'server': server,
'querystring': urllib.urlencode(pad_settings).replace('+', ' '),
'error': _('etherpad-lite session request returned:') +
' "' + e.reason + '"'
},
context_instance=RequestContext(request)
)
return response
def getHTML(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) result = epclient.getHtml(article.id) return result['html']
def EtherMap(self):
epclient = EtherpadLiteClient(self.server.apikey, self.server.apiurl)
result = epclient.createAuthorIfNotExistsFor(self.user.id.__str__(),
name=self.__unicode__())
self.authorID = result['authorID']
return result
def create_ether_user(user):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
result = epclient.createAuthorIfNotExistsFor(user.id, user.username)
user = EtherUser.objects.create(user=user,
user_ether_id=result['authorID'])
return user
def create_community_ether(community):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
result = epclient.createGroupIfNotExistsFor(community.id)
EtherCommunity.objects.create(community=community,
community_ether_id=result['groupID'])
return
'''
Created on 13.11.2011
@author: rene
'''
from py_etherpad import EtherpadLiteClient
myPad = EtherpadLiteClient('WZQfawfPoC8CrAgiBvb2YXCW8sq0EZYX')
#Change the text of the etherpad
vPad = myPad.createGroupIfNotExistsFor(0)
print vPad
#print myPad.getReadOnlyID('TL3400')
te= myPad.listAllPads()
print te
#myPad.setText('testPad','New text from the python wrapper!')
#value = myPad.getText('TL3400')
#print value
#value["text"] = value["text"] + 'test_hhhh'
#print value
#myPad.setText('TL3400',value["text"])
