def update_patch_log(patchmodule):
"""update patch_file in patch log"""
if frappe.db.table_exists("__PatchLog"):
frappe.db.sql("""INSERT INTO `__PatchLog` VALUES (%s, now())""", \
patchmodule)
else:
frappe.doc({"doctype": "Patch Log", "patch": patchmodule}).insert()
def move(name, up_or_down):
ret = None
if not frappe.has_permission("Website Route"):
raise frappe.PermissionError
sitemap = frappe.doc("Website Route", name)
if up_or_down=="up":
if sitemap.idx > 0:
prev = frappe.doc("Website Route", {
"parent_website_route": sitemap.parent_website_route,
"idx": sitemap.idx - 1
})
if prev.name:
prev.idx = prev.idx + 1
prev.save()
sitemap.idx = sitemap.idx - 1
sitemap.save()
ret = "ok"
else:
nexts = frappe.doc("Website Route", {
"parent_website_route": sitemap.parent_website_route,
"idx": sitemap.idx + 1
})
if nexts.name:
nexts.idx = nexts.idx - 1
nexts.save()
sitemap.idx = sitemap.idx + 1
sitemap.save()
ret = "ok"
clear_cache()
return ret
def set_all_patches_as_completed(app):
patch_path = os.path.join(frappe.get_pymodule_path(app), "patches.txt")
if os.path.exists(patch_path):
for patch in frappe.get_file_items(patch_path):
frappe.doc({
"doctype": "Patch Log",
"patch": patch
}).insert()
frappe.db.commit()
def get_notifications():
config = get_notification_config()
can_read = frappe.user.get_can_read()
open_count_doctype = {}
open_count_module = {}
notification_count = dict(
frappe.db.sql(
"""select for_doctype, open_count
from `tabNotification Count` where owner=%s""", (frappe.session.user, )))
for d in config.for_doctype:
if d in can_read:
condition = config.for_doctype[d]
key = condition.keys()[0]
if d in notification_count:
open_count_doctype[d] = notification_count[d]
else:
result = frappe.get_list(
d,
fields=["count(*)"],
filters=[[d, key, "=", condition[key]]],
as_list=True,
limit_page_length=1)[0][0]
frappe.doc({
"doctype": "Notification Count",
"for_doctype": d,
"open_count": result
}).insert()
open_count_doctype[d] = result
for m in config.for_module:
if m in notification_count:
open_count_module[m] = notification_count[m]
else:
open_count_module[m] = frappe.get_attr(config.for_module[m])()
frappe.doc({
"doctype": "Notification Count",
"for_doctype": m,
"open_count": open_count_module[m]
}).insert()
return {
"open_count_doctype": open_count_doctype,
"open_count_module": open_count_module
}
def add(parent, role, permlevel):
frappe.only_for("System Manager")
frappe.doc(
fielddata={
"doctype": "DocPerm",
"__islocal": 1,
"parent": parent,
"parenttype": "DocType",
"parentfield": "permissions",
"role": role,
"permlevel": permlevel,
"read": 1
}).save()
validate_and_reset(parent)
def validate_item(self, item_code, row_num):
from erpnext.stock.doctype.item.item import validate_end_of_life, \
validate_is_stock_item, validate_cancelled_item
# using try except to catch all validation msgs and display together
try:
item = frappe.doc("Item", item_code)
# end of life and stock item
validate_end_of_life(item_code, item.end_of_life, verbose=0)
validate_is_stock_item(item_code, item.is_stock_item, verbose=0)
# item should not be serialized
if item.has_serial_no == "Yes":
raise frappe.ValidationError, (_("Serialized Item: '") + item_code +
_("""' can not be managed using Stock Reconciliation.\
You can add/delete Serial No directly, \
to modify stock of this item."""))
# docstatus should be < 2
validate_cancelled_item(item_code, item.docstatus, verbose=0)
except Exception, e:
self.validation_messages.append(_("Row # ") + ("%d: " % (row_num)) + cstr(e))
def add(email,
sender,
subject,
formatted,
text_content=None,
ref_doctype=None,
ref_docname=None):
"""add to bulk mail queue"""
e = frappe.doc('Bulk Email')
e.sender = sender
e.recipient = email
try:
e.message = get_email(email,
sender=e.sender,
formatted=formatted,
subject=subject,
text_content=text_content).as_string()
except frappe.ValidationError:
# bad email id - don't add to queue
return
e.status = 'Not Sent'
e.ref_doctype = ref_doctype
e.ref_docname = ref_docname
e.save()
def load_country_and_currency(bootinfo):
if bootinfo.control_panel.country and \
frappe.db.exists("Country", bootinfo.control_panel.country):
bootinfo["docs"] += [frappe.doc("Country", bootinfo.control_panel.country)]
bootinfo["docs"] += frappe.db.sql("""select * from tabCurrency
where ifnull(enabled,0)=1""", as_dict=1, update={"doctype":":Currency"})
def __init__(self,
login=None,
password=None,
server=None,
port=None,
use_ssl=None):
# get defaults from control panel
try:
es = frappe.doc('Email Settings', 'Email Settings')
except frappe.DoesNotExistError:
es = None
self._sess = None
if server:
self.server = server
self.port = port
self.use_ssl = cint(use_ssl)
self.login = login
self.password = password
elif es and es.outgoing_mail_server:
self.server = es.outgoing_mail_server
self.port = es.mail_port
self.use_ssl = cint(es.use_ssl)
self.login = es.mail_login
self.password = es.mail_password
self.always_use_login_id_as_sender = es.always_use_login_id_as_sender
else:
self.server = frappe.conf.get("mail_server") or ""
self.port = frappe.conf.get("mail_port") or None
self.use_ssl = cint(frappe.conf.get("use_ssl") or 0)
self.login = frappe.conf.get("mail_login") or ""
self.password = frappe.conf.get("mail_password") or ""
def boot_session(bootinfo):
"""boot session - send website info if guest"""
import frappe
import frappe.model.doc
bootinfo['custom_css'] = frappe.db.get_value('Style Settings', None, 'custom_css') or ''
bootinfo['website_settings'] = frappe.model.doc.getsingle('Website Settings')
if frappe.session['user']!='Guest':
bootinfo['letter_heads'] = get_letter_heads()
load_country_and_currency(bootinfo)
import frappe.model.doctype
bootinfo['notification_settings'] = frappe.doc("Notification Control",
"Notification Control").get_values()
# if no company, show a dialog box to create a new company
bootinfo["customer_count"] = frappe.db.sql("""select count(*) from tabCustomer""")[0][0]
if not bootinfo["customer_count"]:
bootinfo['setup_complete'] = frappe.db.sql("""select name from
tabCompany limit 1""") and 'Yes' or 'No'
# load subscription info
from frappe import conf
for key in ['max_users', 'expires_on', 'max_space', 'status', 'commercial_support']:
if key in conf: bootinfo[key] = conf.get(key)
bootinfo['docs'] += frappe.db.sql("""select name, default_currency, cost_center
from `tabCompany`""", as_dict=1, update={"doctype":":Company"})
def get_context(context):
blog_post = context.bean.doc
# this is for double precaution. usually it wont reach this code if not published
if not cint(blog_post.published):
raise Exception, "This blog has not been published yet!"
# temp fields
blog_post.full_name = get_fullname(blog_post.owner)
blog_post.updated = global_date_format(blog_post.published_on)
if blog_post.blogger:
blog_post.blogger_info = frappe.doc("Blogger", blog_post.blogger).fields
blog_post.description = blog_post.blog_intro or blog_post.content[:140]
blog_post.meta_description = blog_post.description
blog_post.categories = frappe.db.sql_list("select name from `tabBlog Category` order by name")
blog_post.comment_list = frappe.db.sql("""\
select comment, comment_by_fullname, creation
from `tabComment` where comment_doctype="Blog Post"
and comment_docname=%s order by creation""", (blog_post.name,), as_dict=1) or []
return blog_post.fields
def get_context(context):
"""generate rss feed"""
host = get_request_site_address()
blog_list = frappe.db.sql("""\
select page_name as name, published_on, modified, title, content from `tabBlog Post`
where ifnull(published,0)=1
order by published_on desc limit 20""",
as_dict=1)
for blog in blog_list:
blog_page = cstr(urllib.quote(blog.name.encode("utf-8"))) + ".html"
blog.link = urllib.basejoin(host, blog_page)
blog.content = escape_html(blog.content or "")
if blog_list:
modified = max((blog['modified'] for blog in blog_list))
else:
modified = now()
ws = frappe.doc('Website Settings', 'Website Settings')
context = {
'title': ws.title_prefix,
'description': ws.description or ((ws.title_prefix or "") + ' Blog'),
'modified': modified,
'items': blog_list,
'link': host + '/blog'
}
# print context
return context
def set_sidebar_items(sitemap_options, pathname, home_page):
if pathname == home_page or not pathname:
sitemap_options.children = frappe.db.sql(
"""select url as name, label as page_title,
1 as public_read from `tabTop Bar Item` where parentfield='sidebar_items' order by idx""",
as_dict=True)
else:
sitemap_options.children = frappe.db.sql(
"""select * from `tabWebsite Route`
where ifnull(parent_website_route,'')=%s
and public_read=1
order by idx, page_title asc""",
pathname,
as_dict=True)
if sitemap_options.children:
# if children are from generator and sort order is specified, then get that condition
website_template = frappe.doc(
"Website Template",
sitemap_options.children[0].website_template)
if website_template.sort_by != "name":
sitemap_options.children = frappe.db.sql("""select t1.* from
`tabWebsite Route` t1, `tab{ref_doctype}` t2
where ifnull(t1.parent_website_route,'')=%s
and t1.public_read=1
and t1.docname = t2.name
order by t2.{sort_by} {sort_order}""".format(**website_template.fields),
pathname,
as_dict=True)
print sitemap_options.children
def validate(self):
self.set_status()
self.doc.total_hours = 0.0
for d in self.doclist.get({"doctype": "Time Log Batch Detail"}):
tl = frappe.doc("Time Log", d.time_log)
self.update_time_log_values(d, tl)
self.validate_time_log_is_submitted(tl)
self.doc.total_hours += float(tl.hours or 0.0)
def get_messages_from_report(name):
report = frappe.doc("Report", name)
messages = get_messages_from_page_or_report("Report", name,
frappe.db.get_value("DocType", report.ref_doctype, "module"))
if report.query:
messages.extend(re.findall('"([^:,^"]*):', report.query))
messages.append(report.report_name)
return clean(messages)
def setup(self, args=None):
self.email_settings = frappe.doc("Email Settings", "Email Settings")
self.settings = args or frappe._dict(
{
"use_ssl": self.email_settings.support_use_ssl,
"host": self.email_settings.support_host,
"username": self.email_settings.support_username,
"password": self.email_settings.support_password
})
def execute():
frappe.reload_doc("website", "doctype", "contact_us_settings")
address = frappe.db.get_value("Contact Us Settings", None, "address")
if address:
address = frappe.doc("Address", address)
contact = frappe.bean("Contact Us Settings", "Contact Us Settings")
for f in ("address_title", "address_line1", "address_line2", "city", "state", "country", "pincode"):
contact.doc.fields[f] = address.get(f)
contact.save()
def add_all_roles_to(name):
profile = frappe.doc("Profile", name)
for role in frappe.db.sql("""select name from tabRole"""):
if role[0] not in [
"Administrator", "Guest", "All", "Customer", "Supplier",
"Partner"
]:
d = profile.addchild("user_roles", "UserRole")
d.role = role[0]
d.insert()
def get_new_doc(doctype, parent_doc=None, parentfield=None):
doc = frappe.doc({
"doctype": doctype,
"__islocal": 1,
"owner": frappe.session.user,
"docstatus": 0
})
meta = frappe.get_doctype(doctype)
restrictions = frappe.defaults.get_restrictions()
if parent_doc:
doc.parent = parent_doc.name
doc.parenttype = parent_doc.doctype
if parentfield:
doc.parentfield = parentfield
for d in meta.get({"doctype": "DocField", "parent": doctype}):
default = frappe.defaults.get_user_default(d.fieldname)
if (d.fieldtype=="Link") and d.ignore_restrictions != 1 and (d.options in restrictions)\
and len(restrictions[d.options])==1:
doc.fields[d.fieldname] = restrictions[d.options][0]
elif default:
doc.fields[d.fieldname] = default
elif d.fields.get("default"):
if d.default == "__user":
doc.fields[d.fieldname] = frappe.session.user
elif d.default == "Today":
doc.fields[d.fieldname] = nowdate()
elif d.default.startswith(":"):
ref_fieldname = d.default[1:].lower().replace(" ", "_")
if parent_doc:
ref_docname = parent_doc.fields[ref_fieldname]
else:
ref_docname = frappe.db.get_default(ref_fieldname)
doc.fields[d.fieldname] = frappe.db.get_value(
d.default[1:], ref_docname, d.fieldname)
else:
doc.fields[d.fieldname] = d.default
# convert type of default
if d.fieldtype in ("Int", "Check"):
doc.fields[d.fieldname] = cint(doc.fields[d.fieldname])
elif d.fieldtype in ("Float", "Currency"):
doc.fields[d.fieldname] = flt(doc.fields[d.fieldname])
elif d.fieldtype == "Time":
doc.fields[d.fieldname] = nowtime()
return doc
def build_view_context(context):
from frappe.templates.website_group.post import get_post_context
if context.view.name in ("popular", "feed", "open", "closed", "upcoming", "past"):
context.post_list_html = get_post_list_html(context.group.name, context.view.name)
elif context.view.name == "edit":
context.post = frappe.doc("Post", frappe.form_dict.name).fields
if context.post.assigned_to:
context.profile = frappe.doc("Profile", context.post.assigned_to)
elif context.view.name == "settings":
context.profiles = frappe.db.sql("""select p.*, wsp.`read`, wsp.`write`, wsp.`admin`
from `tabProfile` p, `tabWebsite Route Permission` wsp
where wsp.website_route=%s and wsp.profile=p.name""", context.pathname, as_dict=True)
elif context.view.name == "post":
context.update(get_post_context(context))
return context
def add_default(key, value, parent, parenttype=None):
d = frappe.doc({
"doctype": "DefaultValue",
"parent": parent,
"parenttype": parenttype or "Control Panel",
"parentfield": "system_defaults",
"defkey": key,
"defvalue": value
})
d.insert()
if parenttype == "Restriction":
frappe.local.restrictions = None
_clear_cache(parent)
def get_lead_or_customer():
customer = frappe.db.get_value("Contact", {"email_id": frappe.session.user}, "customer")
if customer:
return frappe.doc("Customer", customer)
lead = frappe.db.get_value("Lead", {"email_id": frappe.session.user})
if lead:
return frappe.doc("Lead", lead)
else:
lead_bean = frappe.bean({
"doctype": "Lead",
"email_id": frappe.session.user,
"lead_name": get_fullname(frappe.session.user),
"territory": guess_territory(),
"status": "Open" # TODO: set something better???
})
if frappe.session.user != "Guest":
lead_bean.ignore_permissions = True
lead_bean.insert()
return lead_bean.doc
def update_profile(self):
# add employee role if missing
if not "Employee" in frappe.db.sql_list("""select role from tabUserRole
where parent=%s""", self.doc.user_id):
from frappe.profile import add_role
add_role(self.doc.user_id, "Employee")
profile_wrapper = frappe.bean("Profile", self.doc.user_id)
# copy details like Fullname, DOB and Image to Profile
if self.doc.employee_name:
employee_name = self.doc.employee_name.split(" ")
if len(employee_name) >= 3:
profile_wrapper.doc.last_name = " ".join(employee_name[2:])
profile_wrapper.doc.middle_name = employee_name[1]
elif len(employee_name) == 2:
profile_wrapper.doc.last_name = employee_name[1]
profile_wrapper.doc.first_name = employee_name[0]
if self.doc.date_of_birth:
profile_wrapper.doc.birth_date = self.doc.date_of_birth
if self.doc.gender:
profile_wrapper.doc.gender = self.doc.gender
if self.doc.image:
if not profile_wrapper.doc.user_image == self.doc.image:
profile_wrapper.doc.user_image = self.doc.image
try:
frappe.doc({
"doctype": "File Data",
"file_name": self.doc.image,
"attached_to_doctype": "Profile",
"attached_to_name": self.doc.user_id
}).insert()
except frappe.DuplicateEntryError, e:
# already exists
pass
def make_idx_property_setter(self, doclist, diff_list):
fields = []
doclist.sort(lambda a, b: a.idx < b.idx)
for d in doclist:
if d.doctype=="Customize Form Field":
fields.append(d.fieldname)
d = frappe.doc('Property Setter')
d.doctype_or_field = 'DocType'
d.doc_type = self.doc.doc_type
d.property = "_idx"
d.value = json.dumps(fields)
d.property_type = "Text"
diff_list.append(d)
def build_sitemap_options(path):
sitemap_options = frappe.doc("Website Route", path).fields
home_page = get_home_page()
sitemap_config = frappe.doc("Website Template",
sitemap_options.get("website_template")).fields
# get sitemap config fields too
for fieldname in ("base_template_path", "template_path", "controller",
"no_cache", "no_sitemap", "page_name_field",
"condition_field"):
sitemap_options[fieldname] = sitemap_config.get(fieldname)
sitemap_options.doctype = sitemap_options.ref_doctype
sitemap_options.title = sitemap_options.page_title
sitemap_options.pathname = sitemap_options.name
# establish hierarchy
sitemap_options.parents = frappe.db.sql(
"""select name, page_title from `tabWebsite Route`
where lft < %s and rgt > %s order by lft asc""",
(sitemap_options.lft, sitemap_options.rgt),
as_dict=True)
if not sitemap_options.no_sidebar:
set_sidebar_items(sitemap_options, sitemap_options.pathname, home_page)
if not sitemap_options.children:
set_sidebar_items(sitemap_options,
sitemap_options.parent_website_route, home_page)
# determine templates to be used
if not sitemap_options.base_template_path:
app_base = frappe.get_hooks("base_template")
sitemap_options.base_template_path = app_base[
0] if app_base else "templates/base.html"
return sitemap_options
def validate_item(self):
"""
Validate whether serial no is required for this item
"""
item = frappe.doc("Item", self.doc.item_code)
if item.has_serial_no != "Yes":
frappe.throw(
_("Item must have 'Has Serial No' as 'Yes'") + ": " +
self.doc.item_code)
self.doc.item_group = item.item_group
self.doc.description = item.description
self.doc.item_name = item.item_name
self.doc.brand = item.brand
self.doc.warranty_period = item.warranty_period
def get_context(context):
bloggers = frappe.db.sql("""select * from `tabBlogger`
where ifnull(posts,0) > 0 and ifnull(disabled,0)=0
order by posts desc""", as_dict=1)
writers_context = {
"bloggers": bloggers,
"texts": {
"all_posts_by": "All posts by"
},
"categories": frappe.db.sql_list("select name from `tabBlog Category` order by name")
}
writers_context.update(frappe.doc("Blog Settings", "Blog Settings").fields)
return writers_context
def set_defaults(self):
if frappe.flags.in_import:
return
new_docs = {}
new_doclist = []
for d in self.doclist:
if not d.doctype in new_docs:
new_docs[d.doctype] = frappe.new_doc(d.doctype)
newd = frappe.doc(new_docs[d.doctype].fields.copy())
newd.fields.update(d.fields)
new_doclist.append(newd)
self.set_doclist(new_doclist)
def get_post_context(context):
post = frappe.doc("Post", frappe.form_dict.name)
if post.parent_post:
raise frappe.PermissionError
def _get_post_context():
fullname = get_fullname(post.owner)
return {
"title": "{} by {}".format(post.title, fullname),
"parent_post_html": get_parent_post_html(post, context),
"post_list_html": get_child_posts_html(post, context),
"parent_post": post.name
}
cache_key = "website_group_post:{}".format(post.name)
return frappe.cache().get_value(cache_key, lambda: _get_post_context())
def update_parent(name, new_parent):
if not frappe.has_permission("Website Route"):
raise frappe.PermissionError
sitemap = frappe.doc("Website Route", name)
if sitemap.ref_doctype:
generator = frappe.bean(sitemap.ref_doctype, sitemap.docname)
if not generator.meta.has_field("parent_website_route"):
frappe.throw("Does not allow moving.")
generator.doc.parent_website_route = new_parent
generator.save()
else:
frappe.msgprint("Template Pages cannot be moved.")
clear_cache()
def add_post(group,
content,
picture,
picture_name,
title=None,
parent_post=None,
assigned_to=None,
status=None,
event_datetime=None):
access = get_access(get_pathname(group))
if not access.get("write"):
raise frappe.PermissionError
if parent_post:
if frappe.db.get_value("Post", parent_post, "parent_post"):
frappe.throw("Cannot reply to a reply")
group = frappe.doc("Website Group", group)
post = frappe.bean({
"doctype": "Post",
"title": (title or "").title(),
"content": content,
"website_group": group.name,
"parent_post": parent_post or None
})
if not parent_post:
if group.group_type == "Tasks":
post.doc.is_task = 1
post.doc.assigned_to = assigned_to
elif group.group_type == "Events":
post.doc.is_event = 1
post.doc.event_datetime = event_datetime
post.ignore_permissions = True
post.insert()
if picture_name and picture:
process_picture(post, picture_name, picture)
# send email
if parent_post:
post.run_method("send_email_on_reply")
return post.doc.parent_post or post.doc.name
def update_cart_address(address_fieldname, address_name):
quotation = _get_cart_quotation()
address_display = get_address_display(frappe.doc("Address", address_name).fields)
if address_fieldname == "shipping_address_name":
quotation.doc.shipping_address_name = address_name
quotation.doc.shipping_address = address_display
if not quotation.doc.customer_address:
address_fieldname == "customer_address"
if address_fieldname == "customer_address":
quotation.doc.customer_address = address_name
quotation.doc.address_display = address_display
apply_cart_settings(quotation=quotation)
quotation.ignore_permissions = True
quotation.save()
return get_cart_quotation(quotation.doclist)
def get_active_sessions():
# memcache this
active_sessions = frappe.cache().get_value("website-chat-active-sessions")
if active_sessions==None:
active_sessions = frappe.get_list("Website Chat Session",
fields=["name", "client_name", "status"],
filters={"status":("in", ("Active", "New", "Waiting"))},
order_by="creation desc")
frappe.cache().set_value("website-chat-active-sessions", active_sessions)
return active_sessions
@frappe.whitelist(allow_guest=True)
def end_chat(chatid):
<<<<<<< HEAD
chat = frappe.doc("Website Chat Session", chatid)
chat.status = "Ended"
=======
chat = frappe.get_doc("Website Chat Session", chatid)
chat.status = "Ended"
>>>>>>> frappe/frappe#478
chat.save(ignore_permissions=True)
@frappe.whitelist(allow_guest=True)
def set_feedback(chatid, feedback):
frappe.db.set_value("Website Chat Session", chatid, "feedback", feedback)
@frappe.whitelist()
def set_agent_status(my_status):
agent = frappe.get_doc("Website Chat Agent", {"user": frappe.session.user})
if my_status=="Active":
def get_child_groups(item_group_name):
item_group = frappe.doc("Item Group", item_group_name)
return frappe.conn.sql("""select name
from `tabItem Group` where lft>=%(lft)s and rgt<=%(rgt)s
and show_in_website = 1""", item_group.fields)
def get_parent_item_groups(item_group_name):
item_group = frappe.doc("Item Group", item_group_name)
return frappe.conn.sql("""select name, page_name from `tabItem Group`
where lft <= %s and rgt >= %s
and ifnull(show_in_website,0)=1
order by lft asc""", (item_group.lft, item_group.rgt), as_dict=True)
