def get_page_object(self, path):
'''
Get the page object from the archive folder.
'''
retvar = None
if self.use_static_file:
path_to_page_objectFile = self.get_absolute_path_to_page_object(path)
retvar = fs.exists(path_to_page_objectFile) and True or None
return retvar
def get_backup_page_object(self, path):
'''
Get the backup page object from the template folder.
'''
retvar = None
relativepath_to_page_objectFile = self.get_relative_path_to_page_object(path)
path_to_page_objectFile = tori.path['template'] + "/" + relativepath_to_page_objectFile
retvar = fs.exists(path_to_page_objectFile) and relativepath_to_page_objectFile or None
return retvar
def make_directory_if_not_existed(destination):
if not fs.exists(destination) and mode != ServiceMode.GAE:
try:
fs.mkdir(destination)
except:
raise WebFrameworkException("%s not found" % destination)
def default(self, *paths):
cacheBlockName = "%s/%s" % (self.name, '/'.join(paths))
if self.isGET() and self.cache(cacheBlockName) is not None:
return self.cache(cacheBlockName)
# Response context
response_context = None
# Disable editor mode by default
editor_called = False
# Page mode: reading, editing, overview (TOC)
page_mode = len(paths) > 1 and paths[-1] or None
if page_mode not in [RegisteredMode.edit_content, RegisteredMode.list_page_hierarchy]:
page_mode = None # Assume the reading mode
# Get the whole request path (in array bit) without the page mode
path = len(paths) == 0 and RegisteredPage.index or '/'.join(page_mode == None and paths or paths[:-1])
# Breadcrumb
breadcrumb = []
requested_path = None
if len(paths) > 0:
urlpath = []
requested_path = '/'.join(paths[1:])
for p in paths:
urlpath.append(p)
current_path = '/'.join(urlpath)
p = self.convert_to_full_name(p)
breadcrumb.append({
'URL': current_path,
'Full name': p,
'Short name': self.convert_to_shortname(p)
})
del urlpath
current_page = len(breadcrumb) > 0 and breadcrumb[-1] or None
page_object = self.get_page_object(path)
backup_page_object = self.get_backup_page_object(path)
if self.isGET() and page_mode == None:
is_index_page = path == RegisteredPage.index
do_page_existed = is_index_page or page_object is not None or backup_page_object is not None
# General information
general_information = {
'breadcrumb': breadcrumb,
'current_page': current_page
}
# [General procedure]
# 1. Retrieve the subpages (1 level deep) if necessary
# 2. Render the page object by prioritizing the (HTML) sources in the following order:
# 1. Database entry
# 2. Flat file from archive
# 3. Flat file from template
# Prioritize the one in the database first.
if page_object is not None and not self.use_static_file:
pass
# Prioritize the one in the database first.
if page_object is not None and self.use_static_file:
# Initialize data
templateID = "default" # templateID
subpages = None # list of subpages
path_to_page_object = self.get_absolute_path_to_page_object(path) # path to the page object
pre_processed_page_data = fs.read(path_to_page_object) # pre-processed page data
# Look for requirements
local_flags = re.search("<!--\s*require\s*([a-zA-Z0-9\-\+_]+)\s*-->", pre_processed_page_data)
if local_flags is not None:
# If detect the traversal flag for subpages, do it.
if 'subpages' in local_flags.groups():
subpages = []
possible_directory = self.remove_extension(path_to_page_object)
if fs.exists(possible_directory):
raw_subpages = fs.browse(possible_directory, True)['files']
for p in raw_subpages:
p = re.sub("^" + possible_directory + "/", "", p)
p = self.remove_extension(p)
if p == "index" or p[0] == "_":
continue
subpages.append((self.convert_to_full_name(p), p))
general_information['subpages'] = subpages
# If detect the traversal flag for neighbours, do it.
if 'neighbours' in local_flags.groups():
neighbours = []
possible_directory = re.sub("/[^/]+$", "", self.remove_extension(path_to_page_object))
if fs.exists(possible_directory):
raw_subpages = fs.browse(possible_directory, True)['files']
for p in raw_subpages:
p = re.sub("^" + possible_directory + "/", "", p)
p = self.remove_extension(p)
if p == "index" or p[0] == "_":
continue
neighbours.append((self.convert_to_full_name(p), p))
general_information['neighbours'] = neighbours
# If require syntax highlighting, add the JS code
if 'syntax_highlight' in local_flags.groups():
pre_processed_page_data += self.__JS_code_rendering
# Determine if it needs a special template
local_flags = re.search("<!--\s*template\s*([^ ]+)\s*-->", pre_processed_page_data)
if local_flags is not None:
local_templateID = local_flags.groups()[0]
if local_templateID in self.__templates:
templateID = local_templateID
response_context = self.local_render(pre_processed_page_data, **general_information)
response_context = self.local_render(self.__templates[templateID], response_context = response_context, **general_information)
elif backup_page_object is not None:
response_context = self.local_render(backup_page_object, **general_information)
if not do_page_existed and self.isAdmin() and False:
editor_called = True
elif self.isGET() and page_mode in RegisteredMode.edit_content:
editor_called = True
elif self.isGET() and page_mode == RegisteredMode.list_page_hierarchy:
response_context = tori.UserInterface.response("Table of content (index mode) requested")
elif self.isPOST():
response_context = tori.UserInterface.response("Creating/updating called")
elif self.isDELETE():
response_context = tori.UserInterface.response("Creating/updating called")
# endif
if editor_called:
response_context = self.load_editor(page_mode, '/'.join(len(paths) > 1 and paths[1:-1] or []))
elif not editor_called and response_context is None:
self.respond_status(404)
else:
self.cache(cacheBlockName, response_context, self.__cache_duration)
return response_context
