def generate_search_page(path, terms, page, sort, page_size=DEF_SEARCH_RESULTS):
'''
Generate a search results page.
'''
error = None
# Make sure page is a number, failing on bad input
prev_page = None
if not page:
page = 1
else:
page = int(page)
prev_page = page - 1
# Do the search
# TODO: Add column sort
results = []
is_next_page = False
if (len(terms) < SINGLE_TAG_MAX_LENGTH):
(results, is_next_page) = SavedMacroOps.search(terms, page=page, num=page_size, sort=sort)
else:
error = "Query term too long."
terms = terms[:SINGLE_TAG_MAX_LENGTH] + "..."
# If the number of results is less than that of page_size,
# then there is no next page.
next_page = None
if is_next_page: next_page = page + 1
# If there are no results, add an error.
if not error and len(results) == 0:
error = "No results found."
# TODO: Hook up template controls to sort results.
# TODO: Hook up template controls to page forward/back.
# Return generated search page.
return render_template('base.template',
{'query' : terms,
'content': render_template('search.template',
{'search_error' : error,
'curr_version' : "%s.%s.%s" % (MAJOR_VERSION,
MINOR_VERSION,
PATCH_VERSION),
'query' : terms,
'q_esc' : FORM_QUERY_ESC,
'results' : results,
'sort' : sort,
'page_var' : FORM_SEARCH_PAGE,
# Only give a prev page if we're over page 1.
'prev_page' : prev_page,
'page' : page,
'next_page' : next_page,
},
path)},
path)
def generate_error_page(path, macro=None, error=None):
'''
Generate an error page.
'''
# Create the error string
macro_str = ""
error_str = ""
if macro: macro_str = macro
if error: error_str = error
# Return generated error page.
return render_template('base.template',
{'content': render_template('error.template',
{'input': macro_str,
'error': error_str},
path)},
path)
def get(self):
'''
Display links page.
'''
about = template.render(os.path.join(_TEMPLATE_PATH,
"about.template"),
{});
self.response.out.write(render_template("base.template",
path=_TEMPLATE_PATH,
template_vars={'content': about}))
def generate_api_response(path, macro_id, r_type='xml'):
'''
Generate an XML/JSON interpretation of a macro.
Handles exceptions, returning them as errors in the response.
TO BE WRITTEN: API for response. Use template?
'''
# Can we hit memcached for this?
key = "api_%s_%s" % (macro_id, r_type)
response = memcache.get(key)
if response: return response
# Get parsed macro from id and begin response generation.
response_dict = get_view_dict_from_macro_id(macro_id)
# Call helper to interpret the macro behind the id.
macro_obj = get_macro_obj_from_id(macro_id, response_dict['macro_input'])
# Add macro, with or without errors.
response_dict['interpret'] = _translate_parsed_macro(macro_obj),
# Render to response type requested.
if r_type == 'xml':
response = render_template('xml_response.template',
response_dict,
path)
else: # json
del response_dict['class_list']
del response_dict['macro_input']
response = simplejson.dumps(response_dict)
# Add to memcached
#memcache.add(key, response, MEMCACHED_API)
return response
def generate_edit_page(path, macro=None, save_values={}, macro_id=None):
'''
Generate edit page via template. Exceptions propogated upwards.
Propogates exceptions up.
'''
# Two parts to this page: macro form and link form.
macro_form_html = ''
macro_link_html = ''
# Start filling in the macro form template
macro_form_template_values = {
'intro_text' : FORM_MACRO_INPUT_HELP,
'macro_process': URL_MACRO_PROCESS,
'macro_input_form': FORM_MACRO_INPUT,}
# If we got a macro_id, attempt to get the macro from it.
macro_obj = None
if valid(macro_id):
macro_obj = get_macro_obj_from_id(macro_id)
macro = macro_obj.macro
elif valid(macro):
# Import big modules locally to avoid unneccesary work.
from macro.interpret.interpreter import MacroInterpreter
macro_obj = MacroInterpreter().interpret_macro(macro)
# If we got a good macro, display its interpretation
if valid(macro):
# Add the macro to the form.
if macro_obj.macro_changed:
macro_form_template_values['macro'] = _render_clean_cmd(macro_obj)
macro_form_template_values['changed'] = MACRO_CHANGED
else:
macro_form_template_values['macro'] = macro
# Grab the templates for both the interpretation and the
# processed macro, and populate them.
macro_form_template_values['processed_macro_html'] = \
render_macro(macro_obj, path)
# If we have a valid macro that we could try saving,
# generate form. Also, only do this if we didn't come
# directly from a view--no need to re-save a macro.
if macro_obj.macro_good and not macro_id:
macro_unesc = _render_clean_cmd(macro_obj)
macro_esc = escape(macro_unesc)
macro_link_template_values = {
'title_show' : "none",
'title_hide' : "block",
'notes_show' : "none",
'notes_hide' : "block",
'link_process' : URL_SAVE_PROCESS,
'macro_input_form': FORM_MACRO_INPUT,
'macro' : macro_unesc,
'macro_esc' : macro_esc,
'macro_is_esc ' : FORM_MACRO_ESC,
'title' : FORM_SAVE_TITLE,
'name' : FORM_SAVE_NAME,
'notes' : FORM_SAVE_NOTES,
'server' : FORM_SAVE_SERVER,
'classes' : FORM_SAVE_CLASSES,
'tags' : FORM_SAVE_TAGS,
'note_limit' : NOTES_TEXT_LENGTH,
'note_ch_left' : NOTES_TEXT_LENGTH,
'class_list' : translate_classmap(),
'tag_def_list' : TAG_LIST,
'tag_list' : '',
'server_list' : render_template('servers.template', path=path),
'selected_server' : '',
'curr_version' : "%s.%s.%s" % (MAJOR_VERSION,
MINOR_VERSION,
PATCH_VERSION),
}
# Is this another save attempt after errors? If so, update
# with errors and previous values.
macro_link_template_values.update(save_values)
# Render the template.
macro_link_html = render_template('save_form.template',
macro_link_template_values,
path)
# Add in the link html.
macro_form_template_values['macro_link_html'] = \
macro_link_html
# Render the macro form template html.
ret_page = render_template('macro_form.template',
macro_form_template_values,
path)
return render_template('base.template',
{'content': ret_page },
path)
def generate_view_page(path, macro_id, host_url, save_values={}):
'''
Generate a macro view page. Returns None on error.
Propogates exceptions up.
'''
ret_page = None
# Make sure we got valid input.
if not macro_id: raise NoInputError("You entered an invalid macro ID. Try again?")
# Ensure we have a saved macro. Will throw exception on fail.
saved_macro = SavedMacroOps(macro_id)
# View pages are extremely heavy, and the majority of their
# data doesn't change. Use helper to handle this.
macro_form_template_values = get_view_dict_from_macro_id(macro_id, saved_macro)
# Add in edit and view links.
# Add in the author link.
# Add in the form ids.
page_values = {'macro_link' : '%s/%s' % (host_url,
macro_id),
'macro_edit' : '%s?%s=%s' % (host_url,
GET_MACRO_LINK,
macro_id),
'author' : _format_author(saved_macro.entity.name,
saved_macro.entity.server),
'send_email' : FORM_MACRO_EMAIL,
'send_input_form' : FORM_EMAIL_INPUT,
'to' : FORM_EMAIL_TO,
'from' : FORM_EMAIL_FROM,
}
macro_form_template_values.update(page_values)
# Generate the dynamic parts of the page:
# 1. Increment the view counter on this macro.
# 2. Get the rating in terms of stars for this macro.
dynamic_page_vals = {
'stars' : [i + 1 for i in range(MAX_RATING)],
'num_rates' : saved_macro.entity.num_rates,
'views' : saved_macro.add_to_view_count(),
'rating' : saved_macro.get_rating_dict(saved_macro.get_rating()),
}
macro_form_template_values.update(dynamic_page_vals)
# Is this another save attempt after errors? If so, update
# with errors and previous values.
macro_form_template_values.update(save_values)
# Call helper to interpret the macro behind the id.
macro_obj = get_macro_obj_from_id(macro_id, saved_macro.entity.macro)
# Populate the templace with the processed macro.
macro_form_template_values['processed_macro_html'] = \
render_macro(macro_obj, path)
# Get the copy and paste form of the macro
macro_form_template_values['copy_paste'] = \
_render_copy_cmd(macro_obj)
# Render the macro view template html.
ret_page = render_template('view.template',
macro_form_template_values,
path)
return render_template('base.template',
{'content': ret_page},
path)
