Shiloh/brotherton-erpnext
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:webnotes/erpnext

Browse Source
This commit is contained in:
Rushabh Mehta 2012-12-06 12:16:19 +01:00
commit 63f111be71
15 changed files with 410 additions and 835 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hr/doctype/leave_application/leave_application.py
View File

@ -64,11 +64,11 @@ class DocType:
def validate_balance_leaves(self): def validate_balance_leaves(self):
if self.doc.from_date and self.doc.to_date and not self.is_lwp(): if self.doc.from_date and self.doc.to_date and not self.is_lwp():
bal = get_leave_balance(self.doc.leave_type, self.doc.employee, bal = get_leave_balance(self.doc.leave_type, self.doc.employee,
self.doc.fiscal_year)["leave_balance"] self.doc.fiscal_year)
tot_leaves = self.get_total_leave_days() tot_leaves = self.get_total_leave_days()
bal, tot_leaves = bal, tot_leaves bal, tot_leaves = bal, tot_leaves
webnotes.conn.set(self.doc,'leave_balance',flt(bal['leave_balance'])) webnotes.conn.set(self.doc, 'leave_balance', flt(bal['leave_balance']))
webnotes.conn.set(self.doc,'total_leave_days',flt(tot_leaves['total_leave_days'])) webnotes.conn.set(self.doc, 'total_leave_days', flt(tot_leaves['total_leave_days']))
if flt(bal['leave_balance']) < flt(tot_leaves['total_leave_days']): if flt(bal['leave_balance']) < flt(tot_leaves['total_leave_days']):
msgprint("Warning : There is not enough leave balance") msgprint("Warning : There is not enough leave balance")

4
patches/patch_list.py
View File

@ -725,4 +725,8 @@ patch_list = [
'patch_module': 'patches.december_2012', 'patch_module': 'patches.december_2012',
'patch_file': 'reload_debtors_creditors_ledger', 'patch_file': 'reload_debtors_creditors_ledger',
}, },
{
'patch_module': 'patches.december_2012',
'patch_file': 'website_cache_refactor',
},
] ]

47
stock/doctype/item/item.py
View File

@ -25,9 +25,7 @@ from webnotes import msgprint
sql = webnotes.conn.sql sql = webnotes.conn.sql
class DocType():
class DocType:
def __init__(self, doc, doclist=[]): def __init__(self, doc, doclist=[]):
self.doc = doc self.doc = doc
self.doclist = doclist self.doclist = doclist
@ -40,7 +38,9 @@ class DocType:
return ret return ret
def on_update(self): def on_update(self):
self.update_page_name() # webpage updates
from website.utils import update_page_name
update_page_name(self.doc, self.doc.item_name)
bin = sql("select stock_uom from `tabBin` where item_code = '%s' " % self.doc.item_code) bin = sql("select stock_uom from `tabBin` where item_code = '%s' " % self.doc.item_code)
if bin and cstr(bin[0][0]) != cstr(self.doc.stock_uom): if bin and cstr(bin[0][0]) != cstr(self.doc.stock_uom):
@ -74,8 +74,6 @@ class DocType:
child.conversion_factor = 1 child.conversion_factor = 1
child.save() child.save()
self.clear_web_cache()
# On delete 1. Delete BIN (if none of the corrosponding transactions present, it gets deleted. if present, rolled back due to exception) # On delete 1. Delete BIN (if none of the corrosponding transactions present, it gets deleted. if present, rolled back due to exception)
def on_trash(self): def on_trash(self):
sql("""delete from tabBin where item_code=%s""", self.doc.item_code) sql("""delete from tabBin where item_code=%s""", self.doc.item_code)
@ -194,39 +192,6 @@ class DocType:
def on_rename(self,newdn,olddn): def on_rename(self,newdn,olddn):
sql("update tabItem set item_code = %s where name = %s", (newdn, olddn)) sql("update tabItem set item_code = %s where name = %s", (newdn, olddn))
def delete_web_cache(self, page_name):
import website.web_cache
website.web_cache.delete_cache(page_name)
def clear_web_cache(self):
if hasattr(self, 'old_page_name') and self.old_page_name and \
self.doc.page_name != self.old_page_name:
self.delete_web_cache(self.doc.page_name)
if self.doc.show_in_website:
import website.web_cache
website.web_cache.create_cache(self.doc.page_name, self.doc.doctype, self.doc.name)
website.web_cache.clear_cache(self.doc.page_name, self.doc.doctype, self.doc.name)
else:
self.delete_web_cache(self.doc.page_name)
def update_page_name(self):
import website.utils
# if same name, do not repeat twice
if self.doc.name == self.doc.item_name or not self.doc.item_name:
page_name = self.doc.name
else:
page_name = self.doc.name + " " + self.doc.item_name
self.doc.page_name = website.utils.page_name(page_name)
webnotes.conn.set_value('Item', self.doc.name, 'page_name', self.doc.page_name)
# no need to check for uniqueness, as name is unique
def prepare_template_args(self): def prepare_template_args(self):
import markdown2 self.doc.web_description_html = self.doc.description or ''
self.doc.web_description_html = markdown2.markdown(self.doc.description or '',
extras=["wiki-tables"])

18
website/blog.py
View File

@ -15,12 +15,11 @@ def get_blog_list(args=None):
query = """\ query = """\
select select
cache.name as name, cache.html as content, name, content, owner, creation as creation,
blog.owner as owner, blog.creation as published, title, (select count(name) from `tabComment` where
blog.title as title, (select count(name) from `tabComment` where comment_doctype='Blog' and comment_docname=name) as comments
comment_doctype='Blog' and comment_docname=blog.name) as comments from `tabBlog`
from `tabWeb Cache` cache, `tabBlog` blog where ifnull(published,0)=1
where cache.doc_type = 'Blog' and blog.page_name = cache.name
order by published desc, name asc""" order by published desc, name asc"""
from webnotes.widgets.query_builder import add_limit_to_query from webnotes.widgets.query_builder import add_limit_to_query
@ -35,7 +34,7 @@ def get_blog_list(args=None):
for res in result: for res in result:
from webnotes.utils import global_date_format, get_fullname from webnotes.utils import global_date_format, get_fullname
res['full_name'] = get_fullname(res['owner']) res['full_name'] = get_fullname(res['owner'])
res['published'] = global_date_format(res['published']) res['published'] = global_date_format(res['creation'])
if not res['content']: if not res['content']:
res['content'] = website.web_cache.get_html(res['name']) res['content'] = website.web_cache.get_html(res['name'])
res['content'] = split_blog_content(res['content']) res['content'] = split_blog_content(res['content'])
@ -147,19 +146,14 @@ def add_subscriber():
def get_blog_content(blog_page_name): def get_blog_content(blog_page_name):
import website.web_cache import website.web_cache
content = website.web_cache.get_html(blog_page_name) content = website.web_cache.get_html(blog_page_name)
content = split_blog_content(content) content = split_blog_content(content)
import webnotes.utils import webnotes.utils
content = webnotes.utils.escape_html(content) content = webnotes.utils.escape_html(content)
return content return content
def split_blog_content(content): def split_blog_content(content):
content = content.split("<!-- begin blog content -->") content = content.split("<!-- begin blog content -->")
content = len(content) > 1 and content[1] or content[0] content = len(content) > 1 and content[1] or content[0]
content = content.split("<!-- end blog content -->") content = content.split("<!-- end blog content -->")
content = content[0] content = content[0]
return content return content

28
website/doctype/blog/blog.py
View File

@ -18,20 +18,25 @@ from __future__ import unicode_literals
import webnotes import webnotes
import website.utils import website.utils
import website.web_page
class DocType(website.web_page.Page): class DocType():
def __init__(self, d, dl): def __init__(self, d, dl):
super(DocType, self).__init__('Blog')
self.doc, self.doclist = d, dl self.doc, self.doclist = d, dl
def autoname(self):
from website.utils import page_name
self.doc.name = page_name(self.doc.title)
def on_update(self):
from website.utils import update_page_name
update_page_name(self.doc, self.doc.title)
def send_emails(self): def send_emails(self):
"""send emails to subscribers""" """send emails to subscribers"""
if self.doc.email_sent: if self.doc.email_sent:
webnotes.msgprint("""Blog Subscribers already updated""", raise_exception=1) webnotes.msgprint("""Blog Subscribers already updated""", raise_exception=1)
from webnotes.utils.email_lib.bulk import send from webnotes.utils.email_lib.bulk import send
from markdown2 import markdown
import webnotes.utils import webnotes.utils
# get leads that are subscribed to the blog # get leads that are subscribed to the blog
@ -40,23 +45,15 @@ class DocType(website.web_page.Page):
# make heading as link # make heading as link
content = '<h2><a href="%s/%s.html">%s</a></h2>\n\n%s' % (webnotes.utils.get_request_site_address(), content = '<h2><a href="%s/%s.html">%s</a></h2>\n\n%s' % (webnotes.utils.get_request_site_address(),
self.doc.page_name, self.doc.title, markdown(self.doc.content)) self.doc.page_name, self.doc.title, self.doc.content)
# send the blog # send the blog
send(recipients = recipients, doctype='Lead', email_field='email_id', send(recipients = recipients, doctype='Lead', email_field='email_id',
subject=self.doc.title, message = markdown(content)) subject=self.doc.title, message = content)
webnotes.conn.set(self.doc, 'email_sent', 1) webnotes.conn.set(self.doc, 'email_sent', 1)
webnotes.msgprint("""Scheduled to send to %s subscribers""" % len(recipients)) webnotes.msgprint("""Scheduled to send to %s subscribers""" % len(recipients))
def on_update(self):
super(DocType, self).on_update()
if not webnotes.utils.cint(self.doc.published):
self.delete_web_cache(self.doc.page_name)
else:
import website.blog
website.blog.get_blog_content(self.doc.page_name)
def prepare_template_args(self): def prepare_template_args(self):
import webnotes.utils import webnotes.utils
@ -68,8 +65,7 @@ class DocType(website.web_page.Page):
from webnotes.utils import global_date_format, get_fullname from webnotes.utils import global_date_format, get_fullname
self.doc.full_name = get_fullname(self.doc.owner) self.doc.full_name = get_fullname(self.doc.owner)
self.doc.updated = global_date_format(self.doc.creation) self.doc.updated = global_date_format(self.doc.creation)
self.doc.content_html = self.doc.content
self.markdown_to_html(['content'])
comment_list = webnotes.conn.sql("""\ comment_list = webnotes.conn.sql("""\
select comment, comment_by_fullname, creation select comment, comment_by_fullname, creation

235
website/doctype/blog/blog.txt
View File

@ -1,137 +1,102 @@
# DocType, Blog
[ [
{
# These values are common in all dictionaries "owner": "Administrator",
{ "docstatus": 0,
'creation': '2012-07-27 19:32:53', "creation": "2012-11-30 18:14:18",
'docstatus': 0, "modified_by": "Administrator",
'modified': '2012-08-03 12:18:36', "modified": "2012-12-06 16:33:36"
'modified_by': u'Administrator', },
'owner': u'Administrator' {
}, "allow_attach": 1,
"doctype": "DocType",
# These values are common for all DocType "module": "Website",
{ "max_attachments": 5,
'_last_update': u'1328599743', "name": "__common__"
'allow_attach': 1, },
'colour': u'White:FFF', {
'doctype': 'DocType', "name": "__common__",
'max_attachments': 5, "parent": "Blog",
'module': u'Website', "doctype": "DocField",
'name': '__common__', "parenttype": "DocType",
'section_style': u'Simple', "parentfield": "fields"
'show_in_menu': 0, },
'version': 1 {
}, "name": "__common__",
"parent": "Blog",
# These values are common for all DocField "read": 1,
{ "doctype": "DocPerm",
'doctype': u'DocField', "parenttype": "DocType",
'name': '__common__', "permlevel": 0,
'parent': u'Blog', "parentfield": "permissions"
'parentfield': u'fields', },
'parenttype': u'DocType' {
}, "name": "Blog",
"doctype": "DocType"
# These values are common for all DocPerm },
{ {
'doctype': u'DocPerm', "doctype": "DocField",
'name': '__common__', "label": "Title",
'parent': u'Blog', "fieldname": "title",
'parentfield': u'permissions', "fieldtype": "Data",
'parenttype': u'DocType', "reqd": 1,
'permlevel': 0, "permlevel": 0
'read': 1 },
}, {
"doctype": "DocField",
# DocType, Blog "label": "Published",
{ "fieldname": "published",
'doctype': 'DocType', "fieldtype": "Check",
'name': u'Blog' "permlevel": 0
}, },
{
# DocPerm "doctype": "DocField",
{ "label": "Content",
'create': 1, "fieldname": "content",
'doctype': u'DocPerm', "fieldtype": "Text Editor",
'role': u'Website Manager', "reqd": 0,
'write': 1 "permlevel": 0
}, },
{
# DocPerm "doctype": "DocField",
{ "label": "Page Name",
'create': 1, "fieldname": "page_name",
'doctype': u'DocPerm', "fieldtype": "Data",
'role': u'Blogger', "hidden": 1,
'write': 1 "permlevel": 1
}, },
{
# DocPerm "doctype": "DocField",
{ "label": "Email Sent",
'doctype': u'DocPerm', "fieldname": "email_sent",
'role': u'Guest', "fieldtype": "Check",
'write': 0 "hidden": 1,
}, "permlevel": 0
},
# DocField {
{ "print_hide": 1,
'doctype': u'DocField', "no_copy": 1,
'fieldname': u'title', "doctype": "DocField",
'fieldtype': u'Data', "label": "File List",
'label': u'Title', "fieldname": "file_list",
'permlevel': 0, "fieldtype": "Text",
'reqd': 1 "hidden": 1,
}, "permlevel": 0
},
# DocField {
{ "create": 1,
'doctype': u'DocField', "doctype": "DocPerm",
'fieldname': u'published', "write": 1,
'fieldtype': u'Check', "role": "Website Manager"
'label': u'Published', },
'permlevel': 0 {
}, "create": 1,
"doctype": "DocPerm",
# DocField "write": 1,
{ "role": "Blogger"
'doctype': u'DocField', },
'fieldname': u'content', {
'fieldtype': u'Code', "write": 0,
'label': u'Content', "role": "Guest",
'options': u'Markdown', "doctype": "DocPerm"
'permlevel': 0, }
'reqd': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'page_name',
'fieldtype': u'Data',
'hidden': 1,
'label': u'Page Name',
'permlevel': 1
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'email_sent',
'fieldtype': u'Check',
'hidden': 1,
'label': u'Email Sent',
'permlevel': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'file_list',
'fieldtype': u'Text',
'hidden': 1,
'label': u'File List',
'no_copy': 1,
'permlevel': 0,
'print_hide': 1
}
] ]

1
website/doctype/web_cache/__init__.py
View File

@ -1 +0,0 @@
from __future__ import unicode_literals

22
website/doctype/web_cache/web_cache.py
View File

@ -1,22 +0,0 @@
# ERPNext - web based ERP (http://erpnext.com)
# Copyright (C) 2012 Web Notes Technologies Pvt Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from __future__ import unicode_literals
import webnotes
class DocType:
def __init__(self, d, dl):
self.doc, self.doclist = d, dl

99
website/doctype/web_cache/web_cache.txt
View File

@ -1,99 +0,0 @@
# DocType, Web Cache
[
# These values are common in all dictionaries
{
u'creation': '2012-07-12 22:19:44',
u'docstatus': 0,
u'modified': '2012-09-17 10:48:17',
u'modified_by': u'Administrator',
u'owner': u'Administrator'
},
# These values are common for all DocType
{
u'doctype': u'DocType',
'document_type': u'System',
'module': u'Website',
u'name': u'__common__',
'version': 1
},
# These values are common for all DocField
{
u'doctype': u'DocField',
u'name': u'__common__',
'parent': u'Web Cache',
'parentfield': u'fields',
'parenttype': u'DocType',
'permlevel': 0
},
# These values are common for all DocPerm
{
u'doctype': u'DocPerm',
u'name': u'__common__',
'parent': u'Web Cache',
'parentfield': u'permissions',
'parenttype': u'DocType',
'permlevel': 0,
'read': 1,
'write': 1
},
# DocType, Web Cache
{
u'doctype': u'DocType',
u'name': u'Web Cache'
},
# DocField
{
u'doctype': u'DocField',
'fieldname': u'doc_type',
'fieldtype': u'Link',
'in_filter': 1,
'label': u'DocType',
'options': u'DocType',
'reqd': 1
},
# DocField
{
u'doctype': u'DocField',
'fieldname': u'doc_name',
'fieldtype': u'Data',
'in_filter': 0,
'label': u'DocName',
'reqd': 1
},
# DocField
{
u'doctype': u'DocField',
'fieldname': u'html',
'fieldtype': u'Long Text',
'label': u'HTML'
},
# DocPerm
{
'create': 0,
u'doctype': u'DocPerm',
'role': u'Guest'
},
# DocPerm
{
'create': 1,
u'doctype': u'DocPerm',
'role': u'Website Manager'
},
# DocPerm
{
'create': 1,
u'doctype': u'DocPerm',
'role': u'Blogger'
}
]

22
website/doctype/web_page/web_page.py
View File

@ -16,16 +16,18 @@
from __future__ import unicode_literals from __future__ import unicode_literals
import webnotes import webnotes
import website.utils
import website.web_page
class DocType(website.web_page.Page): class DocType():
def __init__(self, d, dl): def __init__(self, d, dl):
super(DocType, self).__init__('Web Page')
self.doc, self.doclist = d, dl self.doc, self.doclist = d, dl
def autoname(self):
from website.utils import page_name
self.doc.name = page_name(self.doc.title)
def on_update(self): def on_update(self):
super(DocType, self).on_update() from website.utils import update_page_name
update_page_name(self.doc, self.doc.title)
self.if_home_clear_cache() self.if_home_clear_cache()
def if_home_clear_cache(self): def if_home_clear_cache(self):
@ -33,9 +35,11 @@ class DocType(website.web_page.Page):
if webnotes.conn.get_value("Website Settings", None, "home_page")==self.doc.name: if webnotes.conn.get_value("Website Settings", None, "home_page")==self.doc.name:
from webnotes.sessions import clear_cache from webnotes.sessions import clear_cache
clear_cache('Guest') clear_cache('Guest')
import website.web_cache
website.web_cache.clear_cache(self.doc.page_name) from website.web_cache import clear_cache
website.web_cache.clear_cache('index') clear_cache(self.doc.page_name)
clear_cache('index')
def prepare_template_args(self): def prepare_template_args(self):
self.markdown_to_html(['head_section','main_section', 'side_section']) self.doc.main_section_html = self.doc.main_section
self.doc.side_section_html = self.doc.side_section

428
website/doctype/web_page/web_page.txt
View File

@ -1,244 +1,188 @@
# DocType, Web Page
[ [
{
# These values are common in all dictionaries "owner": "Administrator",
{ "docstatus": 0,
'creation': '2012-06-19 15:02:20', "creation": "2012-11-30 18:14:18",
'docstatus': 0, "modified_by": "Administrator",
'modified': '2012-06-22 18:49:02', "modified": "2012-12-06 15:59:02"
'modified_by': u'Administrator', },
'owner': u'Administrator' {
}, "allow_attach": 1,
"doctype": "DocType",
# These values are common for all DocType "module": "Website",
{ "name": "__common__",
'_last_update': u'1328093379', "max_attachments": 20,
'allow_attach': 1, "document_type": "Transaction",
'colour': u'White:FFF', "description": "Page to show on the website\n"
'description': u'A custom page is a simple page with the layout - headline, main section, side section\n\nEditing:\n\n- Editing is in [markdown format](http://daringfireball.net/projects/markdown/syntax)\n- You can also add images and embed html code\n\nAccessing the page:\n\n- The page can be accessed as #![page-name] after the main url\n\nIdeal for pages like FAQ, Terms and Conditions, Help etc.\n\n', },
'doctype': 'DocType', {
'max_attachments': 20, "name": "__common__",
'module': u'Website', "parent": "Web Page",
'name': '__common__', "doctype": "DocField",
'section_style': u'Simple', "parenttype": "DocType",
'show_in_menu': 0, "parentfield": "fields"
'version': 1 },
}, {
"name": "__common__",
# These values are common for all DocField "parent": "Web Page",
{ "read": 1,
'doctype': u'DocField', "submit": 0,
'name': '__common__', "doctype": "DocPerm",
'parent': u'Web Page', "amend": 0,
'parentfield': u'fields', "parenttype": "DocType",
'parenttype': u'DocType' "role": "Website Manager",
}, "parentfield": "permissions"
},
# These values are common for all DocPerm {
{ "name": "Web Page",
'amend': 0, "doctype": "DocType"
'doctype': u'DocPerm', },
'name': '__common__', {
'parent': u'Web Page', "doctype": "DocField",
'parentfield': u'permissions', "label": "Title and Style",
'parenttype': u'DocType', "fieldname": "sb0",
'read': 1, "fieldtype": "Section Break",
'role': u'Website Manager', "permlevel": 0
'submit': 0 },
}, {
"description": "Title / headline of your page",
# DocType, Web Page "colour": "White:FFF",
{ "doctype": "DocField",
'doctype': 'DocType', "label": "Title",
'name': u'Web Page' "fieldname": "title",
}, "fieldtype": "Data",
"reqd": 1,
# DocPerm "permlevel": 0
{ },
'cancel': 1, {
'create': 1, "description": "Page url name (auto-generated) ",
'doctype': u'DocPerm', "colour": "White:FFF",
'permlevel': 0, "doctype": "DocField",
'write': 1 "label": "Page Name",
}, "fieldname": "page_name",
"fieldtype": "Data",
# DocPerm "permlevel": 1
{ },
'cancel': 0, {
'create': 0, "doctype": "DocField",
'doctype': u'DocPerm', "width": "50%",
'permlevel': 1, "fieldname": "cb1",
'write': 0 "fieldtype": "Column Break",
}, "permlevel": 0
},
# DocField {
{ "doctype": "DocField",
'doctype': u'DocField', "label": "Published",
'fieldname': u'sb0', "fieldname": "published",
'fieldtype': u'Section Break', "fieldtype": "Check",
'label': u'Title and Style', "permlevel": 0
'permlevel': 0 },
}, {
"doctype": "DocField",
# DocField "label": "Layout",
{ "options": "Single column\nTwo column",
'colour': u'White:FFF', "fieldname": "layout",
'description': u'Title / headline of your page', "fieldtype": "Select",
'doctype': u'DocField', "permlevel": 0
'fieldname': u'title', },
'fieldtype': u'Data', {
'label': u'Title', "description": "Page content",
'permlevel': 0, "colour": "White:FFF",
'reqd': 1 "doctype": "DocField",
}, "label": "Content",
"fieldname": "sb1",
# DocField "fieldtype": "Section Break",
{ "permlevel": 0
'colour': u'White:FFF', },
'description': u'Page url name (auto-generated) ', {
'doctype': u'DocField', "description": "Content in markdown format that appears on the main side of your page",
'fieldname': u'page_name', "colour": "White:FFF",
'fieldtype': u'Data', "doctype": "DocField",
'label': u'Page Name', "label": "Main Section",
'permlevel': 1 "fieldname": "main_section",
}, "fieldtype": "Text Editor",
"permlevel": 0
# DocField },
{ {
'doctype': u'DocField', "description": "Content in markdown format that appears on the right side",
'fieldname': u'cb1', "colour": "White:FFF",
'fieldtype': u'Column Break', "doctype": "DocField",
'permlevel': 0, "label": "Side Section",
'width': u'50%' "fieldname": "side_section",
}, "fieldtype": "Text Editor",
"permlevel": 0
# DocField },
{ {
'doctype': u'DocField', "description": "Link to other pages in the side bar and next section",
'fieldname': u'layout', "colour": "White:FFF",
'fieldtype': u'Select', "doctype": "DocField",
'label': u'Layout', "label": "More",
'options': u'Single column\nTwo column\nTwo column with header', "fieldname": "sb2",
'permlevel': 0 "fieldtype": "Section Break",
}, "permlevel": 0
},
# DocField {
{ "doctype": "DocField",
'colour': u'White:FFF', "label": "Text Align",
'description': u'Page content', "options": "Left\nCenter\nRight",
'doctype': u'DocField', "fieldname": "text_align",
'fieldname': u'sb1', "fieldtype": "Select",
'fieldtype': u'Section Break', "permlevel": 0
'label': u'Content', },
'permlevel': 0 {
}, "description": "Add code as &lt;script&gt;",
"colour": "White:FFF",
# DocField "doctype": "DocField",
{ "label": "Insert Code",
'colour': u'White:FFF', "fieldname": "insert_code",
'description': u'Section that will span 2 columns, formatted as markdown. If no head, leave blank. If you are displaying a banner, it must be 860px', "fieldtype": "Check",
'doctype': u'DocField', "permlevel": 0
'fieldname': u'head_section', },
'fieldtype': u'Text', {
'label': u'Head Section', "doctype": "DocField",
'options': u'Markdown', "label": "Javascript",
'permlevel': 0 "options": "Javascript",
}, "fieldname": "javascript",
"fieldtype": "Code",
# DocField "permlevel": 0
{ },
'colour': u'White:FFF', {
'description': u'Content in markdown format that appears on the main side of your page', "doctype": "DocField",
'doctype': u'DocField', "label": "Insert Style",
'fieldname': u'main_section', "fieldname": "insert_style",
'fieldtype': u'Code', "fieldtype": "Check",
'label': u'Main Section', "permlevel": 0
'options': u'Markdown', },
'permlevel': 0 {
}, "doctype": "DocField",
"label": "CSS",
# DocField "options": "CSS",
{ "fieldname": "css",
'colour': u'White:FFF', "fieldtype": "Code",
'description': u'Content in markdown format that appears on the right side', "permlevel": 0
'doctype': u'DocField', },
'fieldname': u'side_section', {
'fieldtype': u'Code', "print_hide": 1,
'label': u'Side Section', "no_copy": 1,
'options': u'Markdown', "doctype": "DocField",
'permlevel': 0 "label": "File List",
}, "fieldname": "file_list",
"fieldtype": "Text",
# DocField "hidden": 1,
{ "permlevel": 0
'colour': u'White:FFF', },
'description': u'Link to other pages in the side bar and next section', {
'doctype': u'DocField', "create": 1,
'fieldname': u'sb2', "doctype": "DocPerm",
'fieldtype': u'Section Break', "write": 1,
'label': u'More', "cancel": 1,
'permlevel': 0 "permlevel": 0
}, },
{
# DocField "create": 0,
{ "doctype": "DocPerm",
'doctype': u'DocField', "write": 0,
'fieldname': u'text_align', "cancel": 0,
'fieldtype': u'Select', "permlevel": 1
'label': u'Text Align', }
'options': u'Left\nCenter\nRight',
'permlevel': 0
},
# DocField
{
'colour': u'White:FFF',
'description': u'Add code as &lt;script&gt;',
'doctype': u'DocField',
'fieldname': u'insert_code',
'fieldtype': u'Check',
'label': u'Insert Code',
'permlevel': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'javascript',
'fieldtype': u'Code',
'label': u'Javascript',
'options': u'Javascript',
'permlevel': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'insert_style',
'fieldtype': u'Check',
'label': u'Insert Style',
'permlevel': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'css',
'fieldtype': u'Code',
'label': u'CSS',
'options': u'CSS',
'permlevel': 0
},
# DocField
{
'doctype': u'DocField',
'fieldname': u'file_list',
'fieldtype': u'Text',
'hidden': 1,
'label': u'File List',
'no_copy': 1,
'permlevel': 0,
'print_hide': 1
}
] ]

12
website/doctype/website_settings/website_settings.py
View File

@ -20,11 +20,6 @@ class DocType:
self.doc, self.doclist = d, dl self.doc, self.doclist = d, dl
def validate(self): def validate(self):
"""
* set home page
* validate domain list
* clear cache
"""
self.set_home_page() self.set_home_page()
def on_update(self): def on_update(self):
@ -32,10 +27,9 @@ class DocType:
from webnotes.cms.make import make_web_core from webnotes.cms.make import make_web_core
make_web_core() make_web_core()
# clear web cache # clear web cache (for menus!)
import website.web_cache from website.web_cache import clear_cache
#website.web_cache.refresh_cache(build=['Blog']) clear_cache()
website.web_cache.refresh_cache()
from webnotes.sessions import clear_cache from webnotes.sessions import clear_cache
clear_cache('Guest') clear_cache('Guest')

26
website/utils.py
View File

@ -19,7 +19,6 @@ import webnotes
def render(page_name): def render(page_name):
"""render html page""" """render html page"""
import webnotes
try: try:
if page_name: if page_name:
html = get_html(page_name) html = get_html(page_name)
@ -37,13 +36,11 @@ def get_html(page_name):
page_name = scrub_page_name(page_name) page_name = scrub_page_name(page_name)
comments = get_comments(page_name) comments = get_comments(page_name)
import website.web_cache from website.web_cache import get_page_html
html = website.web_cache.get_html(page_name, comments) html = get_page_html(page_name, comments)
return html return html
def get_comments(page_name): def get_comments(page_name):
import webnotes
if page_name == '404': if page_name == '404':
comments = """error: %s""" % webnotes.getTraceback() comments = """error: %s""" % webnotes.getTraceback()
else: else:
@ -60,9 +57,7 @@ def scrub_page_name(page_name):
def make_template(doc, path, convert_fields = ['main_section', 'side_section']): def make_template(doc, path, convert_fields = ['main_section', 'side_section']):
"""make template""" """make template"""
import os, jinja2 import os, jinja2
markdown(doc, convert_fields)
# write template # write template
with open(path, 'r') as f: with open(path, 'r') as f:
temp = jinja2.Template(f.read()) temp = jinja2.Template(f.read())
@ -75,3 +70,16 @@ def page_name(title):
name = title.lower() name = title.lower()
name = re.sub('[~!@#$%^&*()<>,."\']', '', name) name = re.sub('[~!@#$%^&*()<>,."\']', '', name)
return '-'.join(name.split()[:4]) return '-'.join(name.split()[:4])
def update_page_name(doc, title):
"""set page_name and check if it is unique"""
webnotes.conn.sql(doc, "page_name", title)
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)

215
website/web_cache.py
View File

@ -17,25 +17,29 @@
# html generation functions # html generation functions
from __future__ import unicode_literals from __future__ import unicode_literals
import os
import conf
import webnotes
import website.utils
template_map = { template_map = {
'Web Page': 'html/web_page.html', 'Web Page': 'html/web_page.html',
'Blog': 'html/blog_page.html', 'Blog': 'html/blog_page.html',
'Item': 'html/product_page.html', 'Item': 'html/product_page.html',
} }
def get_html(page_name, comments=''): def get_page_html(page_name, comments=''):
import conf
html = '' html = ''
# load from cache, if auto cache clear is falsy # 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 (hasattr(conf, 'auto_cache_clear') and conf.auto_cache_clear or 0):
html = load_from_cache(page_name) html = webnotes.cache().get_value("page:" + page_name)
comments += "\n\npage load status: from cache" comments += "\n\npage load status: fresh"
if not html: if not html:
html = load_into_cache(page_name) html = load_into_cache(page_name)
comments += "\n\npage load status: fresh" comments += "\n\npage load status: cache"
# insert comments # insert comments
import webnotes.utils import webnotes.utils
@ -43,9 +47,37 @@ def get_html(page_name, comments=''):
return html return html
def load_from_cache(page_name): def load_into_cache(page_name):
import webnotes templates_path = os.path.join(os.path.dirname(conf.__file__),
'app', 'website', 'templates')
args = prepare_args(page_name)
from jinja2 import Environment, FileSystemLoader
jenv = Environment(loader = FileSystemLoader(templates_path))
html = jenv.get_template(args['template']).render(args)
return html
html = build_html()
webnotes.cache().set_value("page:" + page_name, html)
return html
def prepare_args(page_name):
if page_name == 'index':
page_name = get_home_page()
if page_name in get_predefined_pages():
args = {
'template': 'pages/%s.html' % page_name,
'name': page_name,
}
else:
args = get_doc_fields(page_name)
args.update(get_outer_env())
return args
def load_from_cache(page_name):
result = search_cache(page_name) result = search_cache(page_name)
if not result: if not result:
@ -58,61 +90,16 @@ def load_from_cache(page_name):
return result[0][0] return result[0][0]
def load_into_cache(page_name): def get_predefined_pages():
args = prepare_args(page_name)
html = build_html(args)
# create cache entry for predefined pages, if not exists
if page_name in get_predefined_pages():
create_cache(page_name)
import webnotes
webnotes.conn.begin()
webnotes.conn.set_value('Web Cache', page_name, 'html', html)
webnotes.conn.commit()
return html
def get_predefined_pages():
"""
gets a list of predefined pages
they do not exist in `tabWeb Page`
"""
import os
import conf
import website.utils
pages_path = os.path.join(os.path.dirname(conf.__file__), 'app', pages_path = os.path.join(os.path.dirname(conf.__file__), 'app',
'website', 'templates', 'pages') 'website', 'templates', 'pages')
page_list = [] page_list = []
for page in os.listdir(pages_path): for page in os.listdir(pages_path):
page_list.append(website.utils.scrub_page_name(page)) page_list.append(website.utils.scrub_page_name(page))
return page_list return page_list
def prepare_args(page_name):
import webnotes
if page_name == 'index':
page_name = get_home_page()
if page_name in get_predefined_pages():
args = {
'template': 'pages/%s.html' % page_name,
'name': page_name,
'webnotes': webnotes
}
else:
args = get_doc_fields(page_name)
args.update(get_outer_env())
return args
def get_home_page(): def get_home_page():
import webnotes
doc_name = webnotes.conn.get_value('Website Settings', None, 'home_page') doc_name = webnotes.conn.get_value('Website Settings', None, 'home_page')
if doc_name: if doc_name:
page_name = webnotes.conn.get_value('Web Page', doc_name, 'page_name') page_name = webnotes.conn.get_value('Web Page', doc_name, 'page_name')
@ -122,12 +109,9 @@ def get_home_page():
return page_name return page_name
def get_doc_fields(page_name): def get_doc_fields(page_name):
import webnotes doc_type, doc_name = get_source_doc(page_name)
doc_type, doc_name = webnotes.conn.get_value('Web Cache', page_name,
['doc_type', 'doc_name'])
import webnotes.model.code obj = webnotes.get_obj(doc_type, doc_name)
obj = webnotes.model.code.get_obj(doc_type, doc_name)
if hasattr(obj, 'prepare_template_args'): if hasattr(obj, 'prepare_template_args'):
obj.prepare_template_args() obj.prepare_template_args()
@ -137,12 +121,19 @@ def get_doc_fields(page_name):
return args return args
def get_outer_env(): def get_source_doc(page_name):
""" """get source doc for the given page name"""
env dict for outer template for doctype in [('Web Page', 'published'), ('Blog', 'published'),
""" ('Item', 'show_in_website')]:
import webnotes name = webnotes.conn.sql("""select name from `tab%s` where
page_name=%s and ifnull(`%s`, 0)=1""" % (doctype[0], "%s", doctype[1]),
page_name)
if name:
return doctype[0], name[0][0]
return None, None
def get_outer_env():
all_top_items = webnotes.conn.sql("""\ all_top_items = webnotes.conn.sql("""\
select * from `tabTop Bar Item` select * from `tabTop Bar Item`
where parent='Website Settings' and parentfield='top_bar_items' where parent='Website Settings' and parentfield='top_bar_items'
@ -173,97 +164,11 @@ def get_outer_env():
'favicon': webnotes.conn.get_value('Website Settings', None, 'favicon') 'favicon': webnotes.conn.get_value('Website Settings', None, 'favicon')
} }
def build_html(args):
"""
build html using jinja2 templates
"""
import os
import conf
templates_path = os.path.join(os.path.dirname(conf.__file__), 'app', 'website', 'templates')
from jinja2 import Environment, FileSystemLoader
jenv = Environment(loader = FileSystemLoader(templates_path))
html = jenv.get_template(args['template']).render(args)
return html
# cache management
def search_cache(page_name):
if not page_name: return ()
import webnotes
return webnotes.conn.sql("""\
select html, doc_type, doc_name
from `tabWeb Cache`
where name = %s""", page_name)
def create_cache(page_name, doc_type=None, doc_name=None):
# check if a record already exists
result = search_cache(page_name)
if result: return
# create a Web Cache record
import webnotes.model.doc
d = webnotes.model.doc.Document('Web Cache')
d.name = page_name
d.doc_type = doc_type
d.doc_name = doc_name
d.html = None
d.save()
def clear_cache(page_name, doc_type=None, doc_name=None): def clear_cache(page_name, doc_type=None, doc_name=None):
""" if page_name:
* if no page name, clear whole cache delete_page_cache(page_name)
* if page_name, doc_type and doc_name match, clear cache's copy
* else, raise exception that such a page already exists
"""
import webnotes
if not page_name:
webnotes.conn.sql("""update `tabWeb Cache` set html = ''""")
return
result = search_cache(page_name)
if not doc_type or (result and result[0][1] == doc_type and result[0][2] == doc_name):
webnotes.conn.set_value('Web Cache', page_name, 'html', '')
else: else:
webnotes.msgprint("""Page with name "%s" already exists as a %s. webnotes.cache().flush_keys("page:")
Please save it with another name.""" % (page_name, result[0][1]),
raise_exception=1)
def delete_cache(page_name):
"""
delete entry of page_name from Web Cache
used when:
* web page is deleted
* blog is un-published
"""
import webnotes
webnotes.conn.sql("""delete from `tabWeb Cache` where name=%s""", (page_name,))
def refresh_cache(build=None):
"""delete and re-create web cache entries"""
import webnotes
# webnotes.conn.sql("delete from `tabWeb Cache`") def delete_page_cache(page_name):
webnotes.cache().delete_value("page:" + page_name)
clear_cache(None)
query_map = {
'Web Page': """select page_name, name from `tabWeb Page` where docstatus=0""",
'Blog': """\
select page_name, name from `tabBlog`
where docstatus = 0 and ifnull(published, 0) = 1""",
'Item': """\
select page_name, name from `tabItem`
where docstatus = 0 and ifnull(show_in_website, 0) = 1""",
}
for dt in query_map:
if build and dt in build:
for result in webnotes.conn.sql(query_map[dt], as_dict=1):
create_cache(result['page_name'], dt, result['name'])
load_into_cache(result['page_name'])
for page_name in get_predefined_pages():
create_cache(page_name, None, None)
if build: load_into_cache(page_name)

82
website/web_page.py
View File

@ -1,82 +0,0 @@
# ERPNext - web based ERP (http://erpnext.com)
# Copyright (C) 2012 Web Notes Technologies Pvt Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from __future__ import unicode_literals
import webnotes
import website.utils
import website.web_cache
class Page(object):
def __init__(self, doctype):
self.doctype = doctype
def autoname(self):
"""name from title"""
self.doc.name = website.utils.page_name(self.doc.title)
def validate(self):
if self.doc.name:
self.old_page_name = webnotes.conn.get_value(self.doctype, self.doc.name, 'page_name')
def on_update(self):
# page name updates with the title
self.update_page_name()
self.clear_web_cache()
self.doc.save()
def on_trash(self):
"""delete Web Cache entry"""
self.delete_web_cache(self.doc.page_name)
def update_page_name(self):
"""set page_name and check if it is unique"""
self.doc.page_name = website.utils.page_name(self.doc.title)
res = webnotes.conn.sql("""\
select count(*) from `tab%s`
where page_name=%s and name!=%s""" % (self.doctype, '%s', '%s'),
(self.doc.page_name, self.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."""
% (self.doctype, self.doc.name), raise_exception=1)
def clear_web_cache(self):
"""
if web cache entry doesn't exist, it creates one
if duplicate entry exists for another doctype, it raises exception
"""
# delete web cache entry of old name
if hasattr(self, 'old_page_name') and self.old_page_name and \
self.old_page_name != self.doc.page_name:
self.delete_web_cache(self.old_page_name)
website.web_cache.create_cache(self.doc.page_name, self.doc.doctype, self.doc.name)
website.web_cache.clear_cache(self.doc.page_name, self.doc.doctype, self.doc.name)
def delete_web_cache(self, page_name):
"""delete entry of page name from Web Cache"""
website.web_cache.delete_cache(page_name)
def markdown_to_html(self, fields_list):
"""convert fields from markdown to html"""
import markdown2
for f in fields_list:
field_name = "%s_html" % f
self.doc.fields[field_name] = markdown2.markdown(self.doc.fields.get(f) or '', \
extras=["wiki-tables"])