[website] [cleanup] moved website generic utils to framework

public/html/web.py

@@ -39,8 +39,8 @@ def init():
 
 def respond():
 	import webnotes
-	import website.utils
-	return website.utils.render(webnotes.form_dict.get('page'))
+	import webnotes.webutils
+	return webnotes.webutils.render(webnotes.form_dict.get('page'))
 
 if __name__=="__main__":
 	init()

webnotes/handler.py

@@ -230,7 +230,7 @@ def print_page():
 	"""print web page"""
 	print_cookie_header()
 
-	from website.utils import render
+	from webnotes.webutils import render
 	render(webnotes.response['page_name'])
 
 def eprint(content):

webnotes/webutils.py

@@ -0,0 +1,211 @@
+from __future__ import unicode_literals
+
+import os
+import conf
+from startup.website import *
+import webnotes
+import webnotes.utils
+
+def render(page_name):
+	"""render html page"""
+	try:
+		if page_name:
+			html = get_html(page_name)
+		else:
+			html = get_html('index')
+	except Exception:
+		html = get_html('error')
+
+	from webnotes.handler import eprint, print_zip
+	eprint("Content-Type: text/html")
+	print_zip(html)
+
+def get_html(page_name):
+	"""get page html"""
+	page_name = scrub_page_name(page_name)
+	
+	html = ''
+	
+	# load from cache, if auto cache clear is falsy
+	if not (hasattr(conf, 'auto_cache_clear') and conf.auto_cache_clear or 0):
+		if not page_name in no_cache:
+			html = webnotes.cache().get_value("page:" + page_name)
+			from_cache = True
+
+	if not html:
+		from webnotes.auth import HTTPRequest
+		webnotes.http_request = HTTPRequest()
+		
+		#webnotes.connect()
+		html = load_into_cache(page_name)
+		from_cache = False
+	
+	if not html:
+		html = get_html("404")
+
+	if page_name=="error":
+		html = html.replace("%(error)s", webnotes.getTraceback())
+	else:
+		comments = "\n\npage:"+page_name+\
+			"\nload status: " + (from_cache and "cache" or "fresh")
+		html += """\n<!-- %s -->""" % webnotes.utils.cstr(comments)
+
+	return html
+	
+def scrub_page_name(page_name):
+	if page_name.endswith('.html'):
+		page_name = page_name[:-5]
+
+	return page_name
+
+def page_name(title):
+	"""make page name from title"""
+	import re
+	name = title.lower()
+	name = re.sub('[~!@#$%^&*()<>,."\']', '', name)
+	name = re.sub('[:/]', '-', name)
+
+	name = '-'.join(name.split())
+
+	# replace repeating hyphens
+	name = re.sub(r"(-)\1+", r"\1", name)
+	
+	return name
+
+def update_page_name(doc, title):
+	"""set page_name and check if it is unique"""
+	webnotes.conn.set(doc, "page_name", page_name(title))
+	
+	if doc.page_name in standard_pages:
+		webnotes.conn.sql("""Page Name cannot be one of %s""" % ', '.join(standard_pages))
+	
+	res = webnotes.conn.sql("""\
+		select count(*) from `tab%s`
+		where page_name=%s and name!=%s""" % (doc.doctype, '%s', '%s'),
+		(doc.page_name, doc.name))
+	if res and res[0][0] > 0:
+		webnotes.msgprint("""A %s with the same title already exists.
+			Please change the title of %s and save again."""
+			% (doc.doctype, doc.name), raise_exception=1)
+
+	delete_page_cache(doc.page_name)
+
+def load_into_cache(page_name):
+	args = prepare_args(page_name)
+	if not args:
+		return ""
+	html = build_html(args)
+	webnotes.cache().set_value("page:" + page_name, html)
+	return html
+
+def build_html(args):
+	from jinja2 import Environment, FileSystemLoader
+
+	args["len"] = len
+	
+	jenv = Environment(loader = FileSystemLoader(get_templates_path()))
+	html = jenv.get_template(args['template']).render(args)
+	
+	return html
+	
+def prepare_args(page_name):
+	if page_name == 'index':
+		page_name = get_home_page()
+	
+	if page_name in standard_pages:
+		args = webnotes._dict({
+			'template': 'pages/%s.html' % page_name,
+			'name': page_name,
+		})
+		if page_name in page_settings_map:
+			target = page_settings_map[page_name]
+			if "." in target:
+				args.update(webnotes.get_method(target)())
+			else:
+				args.obj = webnotes.bean(page_settings_map[page_name]).obj
+
+	else:
+		args = get_doc_fields(page_name)
+	
+	if not args:
+		return False
+	
+	update_template_args(page_name, args)
+	
+	return args	
+
+def get_doc_fields(page_name):
+	doc_type, doc_name = get_source_doc(page_name)
+	if not doc_type:
+		return False
+	
+	obj = webnotes.get_obj(doc_type, doc_name, with_children=True)
+
+	if hasattr(obj, 'prepare_template_args'):
+		obj.prepare_template_args()
+
+	args = obj.doc.fields
+	args['template'] = page_map[doc_type].template
+	args['obj'] = obj
+	args['int'] = int
+	
+	return args
+
+def get_source_doc(page_name):
+	"""get source doc for the given page name"""
+	for doctype in page_map:
+		name = webnotes.conn.sql("""select name from `tab%s` where 
+			page_name=%s and ifnull(%s, 0)=1""" % (doctype, "%s", 
+			page_map[doctype].condition_field), page_name)
+		if name:
+			return doctype, name[0][0]
+
+	return None, None
+		
+def clear_cache(page_name=None):
+	if page_name:
+		delete_page_cache(page_name)
+	else:
+		cache = webnotes.cache()
+		for p in get_all_pages():
+			cache.delete_value("page:" + p)
+
+def get_all_pages():
+	all_pages = standard_pages
+	all_pages += page_settings_map.keys()
+	for doctype in page_map:
+		all_pages += [p[0] for p in webnotes.conn.sql("""select distinct page_name 
+			from `tab%s`""" % doctype) if p[0]]
+
+	return all_pages
+
+def delete_page_cache(page_name):
+	if page_name:
+		webnotes.cache().delete_value("page:" + page_name)
+			
+def get_hex_shade(color, percent):
+	
+	def p(c):
+		v = int(c, 16) + int(int('ff', 16) * (float(percent)/100))
+		if v < 0: 
+			v=0
+		if v > 255: 
+			v=255
+		h = hex(v)[2:]
+		if len(h) < 2:
+			h = "0" + h
+		return h
+		
+	r, g, b = color[0:2], color[2:4], color[4:6]
+	
+	avg = (float(int(r, 16) + int(g, 16) + int(b, 16)) / 3)
+	# switch dark and light shades
+	if avg > 128:
+		percent = -percent
+
+	# stronger diff for darker shades
+	if percent < 25 and avg < 64:
+		percent = percent * 2
+	
+	return p(r) + p(g) + p(b)
+	

wnf.py

@@ -424,8 +424,8 @@ def run():
 		from website.helpers.make_web_include_files import make
 		make()
 	
-		import website.utils
-		website.utils.clear_cache()
+		import webnotes.webutils
+		webnotes.webutils.clear_cache()
 		
 	elif options.clear_cache:
 		clear_cache()