def updateBlogXML(ident):
from plugin import GENERIC_POST_LINK
rss_file = "blog_%s.xml" % converters.makeLinkAble(ident)
rss_items = []
page_obj = CMSModel.Pages.getPageById(amiweb.session().get(
'current_page_id', 1))
def filterContent(text):
return getFormatManager().htmlFormat(text, False, True, page_obj)
for item in BlogModel.getAllPosts(ident, 10):
if item.isPublished():
item_content = filterContent(item.content)
link = "%s/%s" % (getConfig().BASE_URL,
GENERIC_POST_LINK % item.id)
rss_items.append(
PyRSS2Gen.RSSItem(title=item.title,
link=link,
guid=link,
description="%s" % item_content,
pubDate=item.posted))
host_page = CMSModel.Pages.getPageById(
BlogModel.getBlogByIdent(ident).host_page)
link = "%s/%s" % (getConfig().BASE_URL, host_page.getFullLink())
rss_obj = PyRSS2Gen.RSS2(title=ident,
link=link,
description="",
lastBuildDate=datetime.datetime.now(),
items=rss_items)
getRSSManager().publish(rss_file, rss_obj)
def _genMySqlLogin(self):
if getConfig().DB_PASSWORD != "":
password = "******" % getConfig().DB_PASSWORD
else:
password = ""
return "-h %s -u %s %s %s" %\
(getConfig().DB_HOST, getConfig().DB_USER, password, getConfig().DB_DATABASE)
def addComment(self, author, email, website, content, post_id):
#Check captcha
m = md5.new()
m.update(content)
hash_val = m.hexdigest()
if hash_val != session().get('captcha_ok_for'):
raise Exception('Wrong captcha check')
else:
del session()['captcha_ok_for']
if website != '' and website.find("http://") != 0:
website = "http://%s" % (website)
#Strip scripts, style and meta
content = re.sub('<(script|meta|style)(.|\s)*?>(.|\s)*?</(script|meta|style)>', '', content)
#Check for same URL's posted
try:
self.checkURLSpam(author, content)
except SpamComment:
return '<p><b style="background-color: #ffffcc; color: red">Your comment was marked as spam.</b>, but will be readded if it isn\'t.</p>'
self._expireCache(post_id)
id = BlogCommentModel.add(author, email, website, content, post_id)
email_data = {
'title': 'An comment has been posted',
'author': author,
'email': email,
'website': website,
'content': content,
'delete_link': self._getDeleteURL(id),
'post_id': self._getCommentURL(post_id, id)
}
#Send a notification email
if hasattr(getConfig(), 'DEFAULT_EMAIL'):
text = """%(title)s
Author: %(author)s
Email: %(email)s
Website: %(website)s
Post link: %(post_id)s
Content:
%(content)s
Delete link: %(delete_link)s
""" % email_data
mail = getConfig().DEFAULT_EMAIL
getMailManager().sendEmail(mail, [mail], '[Skeletonz] %s' % email_data['title'], text)
if id:
return renderComment(BlogCommentModel.getById(id), True, False)
else:
return '<p><b style="background-color: #ffffcc; color: red">Your comment was marked as spam.</b>, but will be readded if it isn\'t.</p>'
def restoreDatabase(self, filename):
#Be sure that it's the same prefix!
fp = open(self._getFile(filename), "r")
prefix = fp.readline().replace(prefix_comment, '').strip()
if prefix != getConfig().TABLE_PREFIX:
raise Exception('Backup prefix does not match current. Current prefix: "%s". Backup prefix: "%s"' % \
(getConfig().TABLE_PREFIX, prefix))
self._dropDBManual()
self._runSQLFile(filename)
def __init__(self, prefix):
self.prefix = prefix
#print "[header] Truncator: getConfig().BASE_URL"
self.rel_template = '%s/static/' % getConfig().CURRENT_TEMPLATE.NAME
self.path_template = "%s/templates/%s/static/" % (
os.getcwd(), getConfig().CURRENT_TEMPLATE.NAME)
self.path_static_core = "%s/skeletonz/static/" % os.getcwd()
self.path_static_template = "%s/%s/static/" % (
os.getcwd(), getConfig().CURRENT_TEMPLATE.NAME)
self.memo_css = {}
self.memo_js = {}
def buildList(self, l, static_l, type):
"""
Looks through the list to see if the static files have been updated/created
If they have, we build a new cache
If not, we return the cached version
"""
is_updated = True
new_memo = {}
for url in l:
new_memo[url] = date.today()
"""
last_modif = os.stat(self.getRelative(url)).st_mtime
if type == "css":
v = self.memo_css.pop(url, None)
elif type == "js":
v = self.memo_js.pop(url, None)
#print "%s == %s" % (last_modif, v)
if v == None or v < last_modif:
is_updated = False
#Update new_memo
new_memo[url] = last_modif
"""
if type == "css":
file = "%s/%s/%s_styles.css" % (os.getcwd(), generated_dir,
self.prefix)
self.memo_css = new_memo
elif type == "js":
file = "%s/%s/%s_scripts.js" % (os.getcwd(), generated_dir,
self.prefix)
self.memo_js = new_memo
if not is_updated:
r_list = self.getRelativeList(l)
truncator.minify(r_list, static_l, file)
if type == "css":
return [
"%s/generated/%s_styles.css" %
(getConfig().BASE_URL, self.prefix)
]
elif type == "js":
return [
"%s/generated/%s_scripts.js" %
(getConfig().BASE_URL, self.prefix)
]
def __call__(self, environ, start_response):
path = environ['PATH_INFO']
if path.find("/admin/") == 0:
session = environ['beaker.session']
if session.get('admin_logged_in', False) == False:
raise httpexceptions.HTTPFound("%s/login/" % (getConfig().BASE_URL))
return self.wsgi_app(environ, start_response)
def uploadFile(self, file, ident, ftype, id=0, linkonly=0):
bdata = ""
for l in file.file.readlines():
bdata += l
filename = file.filename.split("\\")
filename = filename[-1:][0]
ns = {
'site': self,
'BASE_URL': getConfig().BASE_URL,
'ident': ident,
'id': id,
'filename': filename,
'ident_id': makeLinkAble(ident),
'linkonly': linkonly,
'ftype': ftype
}
ns['data'] = bdata
if model.Files.countFilesWithFilename(filename):
ns['new_filename'] = model.Files.newFilename(filename)
amiweb.session()['upload_ns'] = ns
return render(
"skeletonz/plugins/upload/view/upload_already_found.tmpl", ns)
return self.uploadComplete(ns)
def _appendGlobalStyle(self):
self.header.appendScript(
'%s/static_core/scripts/general/indicator.js' %
getConfig().BASE_URL)
self.header.appendStaticCoreStyle("/styles/action_links.css")
self.header.appendStaticCoreStyle("/admin/styles/gui.css")
self.header.appendStaticCoreStyle("/admin/styles/content.css")
def appendFilter(self, edit_mode, **kv):
#Extra arguments can be sent and they will be visible from the templates
ident = self.args[self.type]
#Link
link = self.args.get("link", None)
#Hidden
hidden = self.args.get("hidden", None)
ident_id = makeLinkAble(ident)
cur_page_id = self.current_page
if self.args.has_key('global'):
cur_page_id = None
obj = self.get_obj(ident, self.f_type, cur_page_id)
#Set template namespace
ns = {'BASE_URL': getConfig().BASE_URL,
'ident_id': ident_id,
'ident': ident}
try: ns['obj'] = obj
except: pass
#Append extra
for k in kv.keys():
ns[k] = kv[k]
if link:
ns['LINK_START'] = '<a href="%s">' % (link)
ns['LINK_END'] = '</a>'
else:
ns['LINK_START'] = ''
ns['LINK_END'] = ''
if self.args.has_key('align'):
ns['LINK_START'] = '<div style="float: %s">%s' % (self.args['align'], ns['LINK_START'])
ns['LINK_END'] = '%s</div>' % (ns['LINK_END'])
if edit_mode == True:
if obj == None:
replacer = render(self.tmpl_upload_new, ns, True)
else:
replacer = render(self.tmpl_upload_edit, ns, True)
else:
if obj == None:
replacer = render(self.tmpl_view_not_created, ns, True)
else:
if link:
if link == "linkonly":
replacer = render('$obj.getFilename()', ns, True)
else:
replacer = render(self.tmpl_view, ns, True)
elif hidden:
replacer = ""
else:
replacer = render(self.tmpl_view, ns, True)
return "%s" % replacer
def getPageLinkHTML(ident, edit_mode, section, only_form):
from skeletonz.model import CMSModel as Model
from skeletonz.Site import Users
import skeletonz.model.visit as visit
page_link = Model.PageLinks.getPageLinkByIdent(ident)
#If it is None, then it's not created yet!
if page_link == None:
page_link = Model.PageLinks.createPageLink(ident)
url = getConfig().BASE_URL
if edit_mode:
url = '%s/siteedit' % getConfig().BASE_URL
js_update = "EC_Pagelink.update"
if edit_mode:
site_map = visit.getSitemap()
form = visit.createOptions(page_link.getPage(), site_map, page_link.id,
js_update)
if only_form:
return r'%s' % visit.createOptions(page_link.getPage(), site_map,
page_link.id, js_update)
else:
if page_link.getPage() == None:
return r'<span class="page_link_action"><a href="#">$normal_view</a></span> $edit_view %s' %\
(form)
else:
p_url = page_link.getPage().getFullLink()
if section != None:
p_url = "%s#%s" % (p_url, section)
return r'<span class="page_link_action"><a href="%s/%s">$normal_view</a></span> $edit_view %s' %\
(url, p_url, visit.createOptions(page_link.getPage(), site_map, page_link.id, js_update))
else:
if page_link.getPage() == None:
#The page still does not have a reference
return r'<span class="CMS_NotCreated">$normal_view</span>'
else:
page_link = page_link.getPage().getFullLink()
if section is None:
return r'<a href="%s/%s">$normal_view</a>' % (url, page_link)
else:
return r'<a href="%s/%s#%s">$normal_view</a>' % (
url, page_link, section)
def dumpTable(self, table_name):
result = []
mysqldump = getattr(getConfig(), "MYSQL_DUMP", None) or "mysqldump"
dumpcmd = "%s -c %s %s" % \
(mysqldump, self._genMySqlLogin(), table_name)
data = os.popen(dumpcmd, "rb").read()
data = re.sub('DEFAULT CHARSET.*?;', "CHARACTER SET utf8;", data)
return data
def getRelative(self, url):
url = url.replace(getConfig().BASE_URL, "")
if url.find("/static_core/") == 0:
url = "%s%s" % (self.path_static_core,
url.replace("/static_core/", ""))
if url.find(self.rel_template) == 0:
url = "%s%s" % (self.path_template,
url.replace(self.rel_template, ""))
#No it should be realive
return url
def __init__(self):
self.name = NAME
#Set header
self.header = modules.header.SiteHeader()
self.header.appendStyle("%s/%s/static/styles/gui.css" %
(getConfig().BASE_URL, self.name))
self.header.appendStyle("%s/%s/static/styles/content.css" %
(getConfig().BASE_URL, self.name))
#Set content
self.content = modules.content.Content()
#Set menu
self.menu = modules.menu.ListMenu()
modules.sections.mapSection("cms_list_menu", self.menu.renderText)
#Set footer
self.footer = modules.footer.Footer()
def initDatabaseIfNeeded():
try:
mi_control.upgradeToLatest()
except:
debug_info.print_info()
raise
if Model.Menus.getMenuByName("Standard") == None:
menu_obj = Model.Menus.add("Standard", primary=True)
item = Model.MenuItems.add(getConfig().START_PAGE, 1, menu_obj.id)
amiweb.db().update("page", id=item.getPage().id, hidden=0)
def updateCache(self, page_id, new_value):
page_id = str(page_id)
if not getConfig().USE_CACHING:
return new_value
try:
del self.pages_cached[page_id]
except:
pass
self.pages_cached[page_id] = (False, new_value)
return new_value
def __init__(self):
super(SiteHeader, self).__init__('SiteHeader')
self.bodyclass = ''
self.page_obj = None
try:
self.title_prefix = getConfig().TITLE_PREFIX
except:
self.title_prefix = ''
try:
self.title_suffix = getConfig().TITLE_SUFFIX
except:
self.title_suffix = ''
self.edit_mode = False
self.appendStaticCoreStyle("/styles/general.css")
#Append init and greybox styles
self.appendStaticCoreStyle("/greybox/gb_styles.css")
self.appendStaticCoreScript('/scripts/general/init_normal.js')
def dumpDatabase(self, filename):
sql_dump = self.dumpTables()
sql_dump = "%s%s\n%s" %\
(prefix_comment, getConfig().TABLE_PREFIX, sql_dump)
f = open(self._getFile(filename), "w")
f.write(sql_dump)
f.close()
if len(sql_dump) < 500:
print sql_dump[0:100]
raise Exception('ERROR: Something in mysqldump went wrong!')
def showUpload(self, ftype, id=0, linkonly=0):
file = model.Files.getFileById(id)
ns = {
'site': self,
'BASE_URL': getConfig().BASE_URL,
'file': file,
'page_id': amiweb.session()['current_page_id'],
'ftype': ftype,
'linkonly': linkonly
}
return render("skeletonz/plugins/upload/view/upload.tmpl", ns)
def isCacheUp2Date(self, page_id):
page_id = str(page_id)
if not getConfig().USE_CACHING:
return False
#(should_do_update:bool, value)
if self.pages_cached.get(page_id, False):
#Check to see if we should get a new update
if self.pages_cached[page_id][0] == False:
return True
else:
return False
else:
return False
def checkLogin(self, username, password):
if not getConfig().CHECK_LOGIN:
return True
if username == "" or password == "":
return False
if username == getConfig().ADMIN_USERNAME and password == getConfig(
).ADMIN_PASSWORD:
return True
user = self.getUserByUsername(username)
if user == None:
return False
#If an extra function is provided then use it to check password
internal = self.checkPassword(user, password)
try:
external = getConfig().PASSWORD_LOOKUP(username, password)
except AttributeError:
external = False
return internal or external
def __init__(self, name):
self.template = None #Is set from skeletonz/server.py - markChildren
self.styles = []
self.scripts = []
self.script_datas = []
self.styles_datas = []
self.static_script_data = []
self.static_style_data = []
prefix = str(self.__class__)
prefix = prefix.replace("'>", "").split(".")[-1]
self.truncator = Truncator(prefix)
self.setPrefix(name)
self.append_ajs = False
self.sc_path = "%s/static_core" % getConfig().BASE_URL
def cacheAllPages(self):
if not getConfig().USE_CACHING:
return False
#Maybe function called from a new thread
try:
gb = db()
except AttributeError:
setUpConnection()
self.expireAllPages()
pages = Model.Pages.getAllPages()
cur_page = getCurrentPage()
for page in pages:
session()['current_page_id'] = page.id
self.cachePage(page)
session()['current_page_id'] = cur_page
return "ok"
def cachePage(self, page):
print "[amicache] Amicacher cachePage: hit the cache logic<br>"
from skeletonz.Site import Site, renderView, getCurrentInfo
tmpl = getConfig().CURRENT_TEMPLATE.SiteTemplate()
tmpl.markChildren()
site = Site(tmpl)
getFormatManager().resetPagePlugins()
current_info = getCurrentInfo(site.template, page.id, False)
current_info['is_admin'] = False
current_info['logged_in'] = False
current_info['edit_mode'] = False
current_info['edit_permission'] = None
content = renderView(current_info, "site_structure")
#Append sections to this
content = sections.fillSections(current_info, content, page)
self.updateCache(page.id, content)
def renderText(self):
from skeletonz import Site
if Site.Users.getViewEditMode() == 'off':
self.edit_mode = False
#Set the URL
URL = server.getConfig().BASE_URL
self.URL = URL
ns = {
'template': self.template,
'BASE_URL': URL,
'parent_list': self.getParentList(),
'page_obj': self.page_obj,
'bodyclass': self.bodyclass,
'edit_mode': self.edit_mode,
'edit_permission': self.edit_permission,
'logged_in': self.logged_in,
'appendSiteEdit': appendSiteEdit(self.logged_in)
}
return render(
"templates/%s/view/%s" % (self.template.getName(), self.file_name),
ns)
def fn(x):
if x.find(getConfig().TABLE_PREFIX) == 0:
return True
else:
return False
def expireCache(self, page_id):
page_id = str(page_id)
if not getConfig().USE_CACHING:
return False
self.pages_cached[page_id] = (True, None)
def __init__(self):
self.table_prefix = getConfig().TABLE_PREFIX
def expireCurrentPage(self):
if not getConfig().USE_CACHING:
return False
page_id = session()['current_page_id']
self.expireCache(page_id)
def getValue(self, page_id):
page_id = str(page_id)
if not getConfig().USE_CACHING:
return False
return self.pages_cached[page_id][1]
