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)