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 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 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 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 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 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 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')
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 __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 deletePad(article):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
article = EtherArticle.objects.get(article=article)
epclient.deletePad(article.article_ether_id)
def getHTML(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) result = epclient.getHtml(article.id) return result['html']
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
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 deletePad(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) epclient.deletePad(article.id)
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_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
#!/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 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 getText(article): epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL) result = epclient.getText(article.id) return result['text']
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 __init__(self):
self.epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
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 get_pad_usercount(article_id):
epclient = EtherpadLiteClient(settings.APIKEY, settings.APIURL)
padid = get_pad_id(article_id)
count = epclient.padUsersCount(padid)
return count['padUsersCount']
