You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

305 lines
9.1 KiB

  1. # Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
  2. # MIT License. See license.txt
  3. from __future__ import unicode_literals
  4. from webnotes import conf
  5. import webnotes
  6. import json, os, time
  7. from webnotes import _
  8. import webnotes.utils
  9. from webnotes.model.controller import DocListController
  10. import mimetypes
  11. from webnotes.website.doctype.website_sitemap.website_sitemap import add_to_sitemap
  12. class PageNotFoundError(Exception): pass
  13. def render(page_name):
  14. """render html page"""
  15. if not page_name:
  16. page_name = "index"
  17. if "/" in page_name:
  18. page_name = page_name.split("/")[0]
  19. try:
  20. html = render_page(page_name)
  21. except Exception:
  22. html = render_page("error")
  23. set_content_type(page_name)
  24. webnotes._response.data = html
  25. def render_page(page_name):
  26. """get page html"""
  27. if page_name.endswith('.html'):
  28. page_name = page_name[:-5]
  29. html = ''
  30. if not conf.disable_website_cache:
  31. html = webnotes.cache().get_value("page:" + page_name)
  32. from_cache = True
  33. if not html:
  34. html = build_page(page_name)
  35. from_cache = False
  36. if page_name=="error":
  37. html = html.replace("%(error)s", webnotes.get_traceback())
  38. elif is_content_html(page_name):
  39. comments = "\npage:"+page_name+\
  40. "\nload status: " + (from_cache and "cache" or "fresh")
  41. html += """\n<!-- %s -->""" % webnotes.utils.cstr(comments)
  42. return html
  43. def set_content_type(page_name):
  44. webnotes._response.headers["Content-Type"] = "text/html; charset: utf-8"
  45. if not is_content_html(page_name):
  46. content_type, encoding = mimetypes.guess_type(page_name)
  47. webnotes._response.headers["Content-Type"] = content_type
  48. def is_content_html(page_name):
  49. return False if ("." in page_name and not page_name.endswith(".html")) else True
  50. def build_page(page_name):
  51. if not webnotes.conn:
  52. webnotes.connect()
  53. if page_name=="index":
  54. page_name = get_home_page()
  55. try:
  56. sitemap_options = webnotes.doc("Website Sitemap", page_name).fields
  57. page_options = webnotes.doc("Website Sitemap Config",
  58. sitemap_options.get("website_sitemap_config")).fields.update({
  59. "page_name":sitemap_options.page_name,
  60. "docname":sitemap_options.docname
  61. })
  62. except webnotes.DoesNotExistError:
  63. hooks = webnotes.get_hooks()
  64. if hooks.website_catch_all:
  65. return build_page(hooks.website_catch_all[0])
  66. else:
  67. return build_page("404")
  68. page_options["page_name"] = page_name
  69. no_cache = page_options.get("no_cache")
  70. # if generator, then load bean, pass arguments
  71. if page_options.get("page_or_generator")=="Generator":
  72. bean = webnotes.bean(page_options.get("ref_doctype"), page_options["docname"])
  73. bean.run_method("get_context")
  74. context = webnotes._dict(bean.doc.fields)
  75. context["obj"] = bean.get_controller()
  76. else:
  77. # page
  78. context = webnotes._dict({ 'name': page_name })
  79. if page_options.get("controller"):
  80. module = webnotes.get_module(page_options.get("controller"))
  81. if module and hasattr(module, "get_context"):
  82. context.update(module.get_context())
  83. context.update(get_website_settings())
  84. jenv = webnotes.get_jenv()
  85. context["base_template"] = jenv.get_template("templates/base.html")
  86. template_name = page_options['template_path']
  87. context["_"] = webnotes._
  88. html = jenv.get_template(template_name).render(context)
  89. if not no_cache:
  90. webnotes.cache().set_value("page:" + page_name, html)
  91. return html
  92. def get_home_page():
  93. return webnotes.cache().get_value("home_page", \
  94. lambda: webnotes.conn.get_value("Website Settings", None, "home_page") or "login")
  95. def get_website_settings():
  96. from webnotes.utils import get_request_site_address, encode, cint
  97. from urllib import quote
  98. hooks = webnotes.get_hooks()
  99. all_top_items = webnotes.conn.sql("""\
  100. select * from `tabTop Bar Item`
  101. where parent='Website Settings' and parentfield='top_bar_items'
  102. order by idx asc""", as_dict=1)
  103. top_items = [d for d in all_top_items if not d['parent_label']]
  104. # attach child items to top bar
  105. for d in all_top_items:
  106. if d['parent_label']:
  107. for t in top_items:
  108. if t['label']==d['parent_label']:
  109. if not 'child_items' in t:
  110. t['child_items'] = []
  111. t['child_items'].append(d)
  112. break
  113. context = webnotes._dict({
  114. 'top_bar_items': top_items,
  115. 'footer_items': webnotes.conn.sql("""\
  116. select * from `tabTop Bar Item`
  117. where parent='Website Settings' and parentfield='footer_items'
  118. order by idx asc""", as_dict=1),
  119. "webnotes": webnotes,
  120. "utils": webnotes.utils,
  121. "post_login": [
  122. {"label": "Reset Password", "url": "update-password", "icon": "icon-key"},
  123. {"label": "Logout", "url": "/?cmd=web_logout", "icon": "icon-signout"}
  124. ]
  125. })
  126. settings = webnotes.doc("Website Settings", "Website Settings")
  127. for k in ["banner_html", "brand_html", "copyright", "twitter_share_via",
  128. "favicon", "facebook_share", "google_plus_one", "twitter_share", "linked_in_share",
  129. "disable_signup"]:
  130. if k in settings.fields:
  131. context[k] = settings.fields.get(k)
  132. if settings.address:
  133. context["footer_address"] = settings.address
  134. for k in ["facebook_share", "google_plus_one", "twitter_share", "linked_in_share",
  135. "disable_signup"]:
  136. context[k] = cint(context.get(k) or 0)
  137. context.url = quote(str(get_request_site_address(full_address=True)), str(""))
  138. context.encoded_title = quote(encode(context.title or ""), str(""))
  139. for update_website_context in hooks.update_website_context or []:
  140. webnotes.get_attr(update_website_context)(context)
  141. context.web_include_js = hooks.web_include_js or []
  142. context.web_include_css = hooks.web_include_css or []
  143. return context
  144. def clear_cache(page_name=None):
  145. if page_name:
  146. delete_page_cache(page_name)
  147. else:
  148. cache = webnotes.cache()
  149. for p in webnotes.conn.sql_list("""select name from `tabWebsite Sitemap`"""):
  150. if p is not None:
  151. cache.delete_value("page:" + p)
  152. cache.delete_value("home_page")
  153. cache.delete_value("page:index")
  154. cache.delete_value("website_sitemap")
  155. cache.delete_value("website_sitemap_config")
  156. def delete_page_cache(page_name):
  157. if page_name:
  158. cache = webnotes.cache()
  159. cache.delete_value("page:" + page_name)
  160. cache.delete_value("website_sitemap")
  161. def is_signup_enabled():
  162. if getattr(webnotes.local, "is_signup_enabled", None) is None:
  163. webnotes.local.is_signup_enabled = True
  164. if webnotes.utils.cint(webnotes.conn.get_value("Website Settings",
  165. "Website Settings", "disable_signup")):
  166. webnotes.local.is_signup_enabled = False
  167. return webnotes.local.is_signup_enabled
  168. def call_website_generator(bean, method):
  169. getattr(WebsiteGenerator(bean.doc, bean.doclist), method)()
  170. class WebsiteGenerator(DocListController):
  171. def setup_generator(self):
  172. if webnotes.flags.in_install_app:
  173. return
  174. self._website_config = webnotes.conn.get_values("Website Sitemap Config",
  175. {"ref_doctype": self.doc.doctype}, "*")[0]
  176. def on_update(self, page_name=None):
  177. if webnotes.flags.in_install_app:
  178. return
  179. self.setup_generator()
  180. if self._website_config.condition_field:
  181. if not self.doc.fields.get(self._website_config.condition_field):
  182. # condition field failed, return
  183. remove_page(self.doc.fields.get(self._website_config.page_name_field))
  184. return
  185. if not page_name:
  186. new_page_name = cleanup_page_name(self.get_page_title() \
  187. if hasattr(self, "get_page_title") else (self.doc.title or self.doc.name))
  188. self.check_if_page_name_is_unique(new_page_name)
  189. remove_page(self.doc.page_name)
  190. if self.doc.fields.get(self._website_config.page_name_field)!=new_page_name:
  191. webnotes.conn.set(self.doc, self._website_config.page_name_field, new_page_name)
  192. page_name = new_page_name
  193. add_to_sitemap(webnotes._dict({
  194. "ref_doctype":self.doc.doctype,
  195. "docname": self.doc.name,
  196. "page_name": page_name,
  197. "link_name": self._website_config.name,
  198. "lastmod": webnotes.utils.get_datetime(self.doc.modified).strftime("%Y-%m-%d")
  199. }))
  200. def check_if_page_name_is_unique(self, new_page_name):
  201. if webnotes.conn.sql("""select name from `tabWebsite Sitemap` where name=%s
  202. and website_sitemap_config!=%s and docname!=%s""", (new_page_name,
  203. self._website_config.name, self.doc.name)):
  204. webnotes.throw("%s: %s. %s: <b>%s<b>" % (new_page_name, _("Page already exists"),
  205. _("Please change the value"), self.doc.title))
  206. def on_trash(self):
  207. self.setup_generator()
  208. remove_page(self.doc.fields[self._website_config.page_name_field])
  209. def remove_page(page_name):
  210. if page_name:
  211. delete_page_cache(page_name)
  212. webnotes.conn.sql("delete from `tabWebsite Sitemap` where name=%s", page_name)
  213. def cleanup_page_name(title):
  214. """make page name from title"""
  215. import re
  216. name = title.lower()
  217. name = re.sub('[~!@#$%^&*+()<>,."\'\?]', '', name)
  218. name = re.sub('[:/]', '-', name)
  219. name = '-'.join(name.split())
  220. # replace repeating hyphens
  221. name = re.sub(r"(-)\1+", r"\1", name)
  222. return name
  223. def get_hex_shade(color, percent):
  224. def p(c):
  225. v = int(c, 16) + int(int('ff', 16) * (float(percent)/100))
  226. if v < 0:
  227. v=0
  228. if v > 255:
  229. v=255
  230. h = hex(v)[2:]
  231. if len(h) < 2:
  232. h = "0" + h
  233. return h
  234. r, g, b = color[0:2], color[2:4], color[4:6]
  235. avg = (float(int(r, 16) + int(g, 16) + int(b, 16)) / 3)
  236. # switch dark and light shades
  237. if avg > 128:
  238. percent = -percent
  239. # stronger diff for darker shades
  240. if percent < 25 and avg < 64:
  241. percent = percent * 2
  242. return p(r) + p(g) + p(b)