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 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"])