Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
 
 
 
 
 
 

302 linhas
8.7 KiB

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