def post_install(rebuild_website=False): if rebuild_website: render.clear_cache() init_singles() frappe.db.commit() frappe.clear_cache()
def update_comments_in_parent(reference_doctype, reference_name, _comments):
"""Updates `_comments` property in parent Document with given dict.
:param _comments: Dict of comments."""
if not reference_doctype or frappe.db.get_value("DocType", reference_doctype, "issingle"):
return
try:
# use sql, so that we do not mess with the timestamp
frappe.db.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (reference_doctype,
"%s", "%s"), (json.dumps(_comments), reference_name))
except Exception as e:
if e.args[0] == 1054 and getattr(frappe.local, 'request', None):
# missing column and in request, add column and update after commit
frappe.local._comments = (getattr(frappe.local, "_comments", [])
+ [(reference_doctype, reference_name, _comments)])
else:
raise ImplicitCommitError
else:
if not frappe.flags.in_patch:
reference_doc = frappe.get_doc(reference_doctype, reference_name)
if getattr(reference_doc, "route", None):
clear_cache(reference_doc.route)
def move(name, up_or_down):
ret = None
if not frappe.has_permission("Website Route"):
raise frappe.PermissionError
sitemap = frappe.get_doc("Website Route", name)
if up_or_down=="up":
if sitemap.idx > 0:
prev = frappe.get_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.get_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 build_website(verbose=False): from frappe.website import render, statics frappe.connect() render.clear_cache() statics.sync(verbose=verbose).start(True) frappe.db.commit() frappe.destroy()
def migrate(verbose=True, rebuild_website=False):
'''Migrate all apps to the latest version, will:
- run patches
- sync doctypes (schema)
- sync fixtures
- sync desktop icons
- sync web pages (from /www)'''
clear_global_cache()
# run patches
frappe.modules.patch_handler.run_all()
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_fixtures()
sync_desktop_icons()
# syncs statics
render.clear_cache()
if rebuild_website:
statics.sync(verbose=verbose).start(True)
else:
statics.sync_statics()
frappe.db.commit()
clear_notifications()
frappe.publish_realtime("version-update")
def invalidate_cache_for(bean, trigger, item_group=None): if not item_group: item_group = bean.doc.name for i in get_parent_item_groups(item_group): if i.page_name: clear_cache(i.page_name)
def invalidate_cache_for(doc, item_group=None): if not item_group: item_group = doc.name for i in get_parent_item_groups(item_group): if i.page_name: clear_cache(i.page_name)
def migrate(verbose=True, rebuild_website=False):
'''Migrate all apps to the latest version, will:
- run before migrate hooks
- run patches
- sync doctypes (schema)
- sync fixtures
- sync desktop icons
- sync web pages (from /www)
- sync web pages (from /www)
- run after migrate hooks
'''
touched_tables_file = frappe.get_site_path('touched_tables.json')
if os.path.exists(touched_tables_file):
os.remove(touched_tables_file)
try:
frappe.flags.touched_tables = set()
frappe.flags.in_migrate = True
clear_global_cache()
#run before_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('before_migrate', app_name=app):
frappe.get_attr(fn)()
# run patches
frappe.modules.patch_handler.run_all()
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_fixtures()
sync_customizations()
sync_desktop_icons()
sync_languages()
frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()
# syncs statics
render.clear_cache()
# add static pages to global search
router.sync_global_search()
#run after_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('after_migrate', app_name=app):
frappe.get_attr(fn)()
frappe.db.commit()
clear_notifications()
frappe.publish_realtime("version-update")
frappe.flags.in_migrate = False
finally:
with open(touched_tables_file, 'w') as f:
json.dump(list(frappe.flags.touched_tables), f, sort_keys=True, indent=4)
frappe.flags.touched_tables.clear()
def invalidate_cache_for(doc, item_group=None):
if not item_group:
item_group = doc.name
for d in get_parent_item_groups(item_group):
item_group_name = frappe.db.get_value("Item Group", d.get('name'))
if item_group_name:
clear_cache(frappe.db.get_value('Item Group', item_group_name, 'route'))
def update_comments_in_parent(self, _comments):
# use sql, so that we do not mess with the timestamp
frappe.db.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (self.comment_doctype,
"%s", "%s"), (json.dumps(_comments), self.comment_docname))
comment_doc = frappe.get_doc(self.comment_doctype, self.comment_docname)
if getattr(comment_doc, "get_route", None):
clear_cache(comment_doc.get_route())
def invalidate_cache_for(doc, item_group=None):
if not item_group:
item_group = doc.name
for d in get_parent_item_groups(item_group):
d = frappe.get_doc("Item Group", d.name)
if d.route:
clear_cache(d.route)
def add_comment(args=None):
"""
args = {
'comment': '',
'comment_by': '',
'comment_by_fullname': '',
'comment_doctype': '',
'comment_docname': '',
'page_name': '',
}
"""
if not args:
args = frappe.local.form_dict
args["doctype"] = "Comment"
page_name = args.get("page_name")
if "page_name" in args:
del args["page_name"]
if "cmd" in args:
del args["cmd"]
comment = frappe.get_doc(args)
comment.ignore_permissions = True
comment.insert()
# since comments are embedded in the page, clear the web cache
clear_cache(page_name)
# notify commentors
commentors = [
d[0]
for d in frappe.db.sql(
"""select comment_by from tabComment where
comment_doctype=%s and comment_docname=%s and
ifnull(unsubscribed, 0)=0""",
(comment.comment_doctype, comment.comment_docname),
)
]
owner = frappe.db.get_value(comment.comment_doctype, comment.comment_docname, "owner")
recipients = commentors if owner == "Administrator" else list(set(commentors + [owner]))
from frappe.utils.email_lib.bulk import send
send(
recipients=recipients,
doctype="Comment",
email_field="comment_by",
subject=_("New comment on {0} {1}").format(comment.comment_doctype, comment.comment_docname),
message=_("{0} by {1}").format(markdown2.markdown(args.get("comment")), comment.comment_by_fullname),
ref_doctype=comment.comment_doctype,
ref_docname=comment.comment_docname,
)
template = frappe.get_template("templates/includes/comment.html")
return template.render({"comment": comment.as_dict()})
def on_update(self): # make js and css # clear web cache (for menus!) from frappe.website.render import clear_cache clear_cache() # clears role based home pages frappe.clear_cache()
def after_rename(self, olddn, newdn, merge):
super(Item, self).after_rename(olddn, newdn, merge)
if self.page_name:
invalidate_cache_for_item(self)
clear_cache(self.page_name)
frappe.db.set_value("Item", newdn, "item_code", newdn)
if merge:
self.set_last_purchase_rate(newdn)
self.recalculate_bin_qty(newdn)
def after_install(rebuild_website=False):
version = frappe.utils.cint(frappe.__version__.split(".", 1)[0])
if version >= 5:
return
if rebuild_website:
render.clear_cache()
statics.sync().start()
init_singles()
frappe.db.commit()
frappe.clear_cache()
def update_comments_in_parent(self, _comments):
# use sql, so that we do not mess with the timestamp
frappe.db.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (self.comment_doctype,
"%s", "%s"), (json.dumps(_comments), self.comment_docname))
# clear parent cache if route exists:
route = frappe.db.get_value("Website Route", {"ref_doctype": self.comment_doctype,
"docname": self.comment_docname})
if route:
clear_cache(route)
def build_website(context): "Sync statics and clear cache" from frappe.website import render, statics for site in context.sites: try: frappe.init(site=site) frappe.connect() render.clear_cache() statics.sync(verbose=context.verbose).start(True) frappe.db.commit() finally: frappe.destroy()
def add_comment(args=None):
"""
args = {
'comment': '',
'comment_by': '',
'comment_by_fullname': '',
'comment_doctype': '',
'comment_docname': '',
'page_name': '',
}
"""
if not args:
args = frappe.local.form_dict
args['doctype'] = "Comment"
page_name = args.get("page_name")
if "page_name" in args:
del args["page_name"]
if "cmd" in args:
del args["cmd"]
comment = frappe.get_doc(args)
comment.comment_type = "Comment"
comment.flags.ignore_permissions = True
comment.insert()
# since comments are embedded in the page, clear the web cache
clear_cache(page_name)
# notify commentors
commentors = [d[0] for d in frappe.db.sql("""select comment_by from tabComment where
comment_doctype=%s and comment_docname=%s and
ifnull(unsubscribed, 0)=0""", (comment.comment_doctype, comment.comment_docname))]
owner = frappe.db.get_value(comment.comment_doctype, comment.comment_docname, "owner")
recipients = list(set(commentors if owner=="Administrator" else (commentors + [owner])))
message = _("{0} by {1}").format(markdown2.markdown(args.get("comment")), comment.comment_by_fullname)
message += "<p><a href='{0}/{1}' style='font-size: 80%'>{2}</a></p>".format(frappe.utils.get_request_site_address(),
page_name, _("View it in your browser"))
from frappe.email.bulk import send
send(recipients=recipients,
subject = _("New comment on {0} {1}").format(comment.comment_doctype, comment.comment_docname),
message = message,
reference_doctype=comment.comment_doctype, reference_name=comment.comment_docname)
template = frappe.get_template("templates/includes/comments/comment.html")
return template.render({"comment": comment.as_dict()})
def add_to_installed_apps(app_name, rebuild_website=True):
installed_apps = frappe.get_installed_apps()
if not app_name in installed_apps:
installed_apps.append(app_name)
frappe.db.set_global("installed_apps", json.dumps(installed_apps))
frappe.db.commit()
if rebuild_website:
render.clear_cache()
statics.sync().start()
frappe.db.commit()
frappe.clear_cache()
def update_comments_in_parent(self, _comments):
"""Updates `_comments` property in parent Document with given dict.
:param _comments: Dict of comments."""
if not self.comment_doctype or frappe.db.get_value("DocType", self.comment_doctype, "issingle"):
return
# use sql, so that we do not mess with the timestamp
frappe.db.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (self.comment_doctype,
"%s", "%s"), (json.dumps(_comments), self.comment_docname))
comment_doc = frappe.get_doc(self.comment_doctype, self.comment_docname)
if getattr(comment_doc, "get_route", None):
clear_cache(comment_doc.get_route())
def add_comment(args=None):
"""
args = {
'comment': '',
'comment_by': '',
'comment_by_fullname': '',
'reference_doctype': '',
'reference_name': '',
'route': '',
}
"""
if not args:
args = frappe.local.form_dict
route = args.get("route")
doc = frappe.get_doc(args["reference_doctype"], args["reference_name"])
comment = doc.add_comment("Comment", args["comment"], comment_by=args["comment_by"])
comment.flags.ignore_permissions = True
comment.sender_full_name = args["comment_by_fullname"]
comment.save()
# since comments are embedded in the page, clear the web cache
clear_cache(route)
# notify commentors
commentors = [d[0] for d in frappe.db.sql("""select sender from `tabCommunication`
where
communication_type = 'Comment' and comment_type = 'Comment'
and reference_doctype=%s
and reference_name=%s""", (comment.reference_doctype, comment.reference_name))]
owner = frappe.db.get_value(doc.doctype, doc.name, "owner")
recipients = list(set(commentors if owner=="Administrator" else (commentors + [owner])))
message = _("{0} by {1}").format(frappe.utils.markdown(args.get("comment")), comment.sender_full_name)
message += "<p><a href='{0}/{1}' style='font-size: 80%'>{2}</a></p>".format(frappe.utils.get_request_site_address(),
route, _("View it in your browser"))
from frappe.email.queue import send
send(recipients=recipients,
subject = _("New comment on {0} {1}").format(doc.doctype, doc.name),
message = message,
reference_doctype=doc.doctype, reference_name=doc.name)
template = frappe.get_template("templates/includes/comments/comment.html")
return template.render({"comment": comment.as_dict()})
def migrate(verbose=True, rebuild_website=False):
'''Migrate all apps to the latest version, will:
- run before migrate hooks
- run patches
- sync doctypes (schema)
- sync fixtures
- sync desktop icons
- sync web pages (from /www)
- sync web pages (from /www)
- run after migrate hooks
'''
frappe.flags.in_migrate = True
clear_global_cache()
#run before_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('before_migrate', app_name=app):
frappe.get_attr(fn)()
# run patches
frappe.modules.patch_handler.run_all()
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_fixtures()
sync_customizations()
sync_desktop_icons()
sync_languages()
frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()
# syncs statics
render.clear_cache()
# add static pages to global search
router.sync_global_search()
#run after_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('after_migrate', app_name=app):
frappe.get_attr(fn)()
frappe.db.commit()
clear_notifications()
frappe.publish_realtime("version-update")
frappe.flags.in_migrate = False
def update_parent(name, new_parent):
if not frappe.has_permission("Website Route"):
raise frappe.PermissionError
sitemap = frappe.get_doc("Website Route", name)
if sitemap.ref_doctype:
generator = frappe.get_doc(sitemap.ref_doctype, sitemap.docname)
if not generator.meta.get_field("parent_website_route"):
frappe.throw(_("Not allowed to move"))
generator.parent_website_route = new_parent
generator.save()
else:
frappe.msgprint(_("Template Pages cannot be moved"))
clear_cache()
def update_routes_of_descendants(self, old_route = None):
if not self.is_new() and self.meta.get_field("parent_website_route"):
if not old_route:
old_route = frappe.get_doc(self.doctype, self.name).get_route()
if old_route and old_route != self.get_route():
# clear cache of old routes
old_routes = frappe.get_all(self.doctype, filters={"parent_website_route": ("like", old_route + "%")})
if old_routes:
for like_old_route in old_routes:
clear_cache(frappe.get_doc(self.doctype, like_old_route.name).get_route())
frappe.db.sql("""update `tab{0}` set
parent_website_route = replace(parent_website_route, %s, %s),
modified = %s,
modified_by = %s
where parent_website_route like %s""".format(self.doctype),
(old_route, self.get_route(), now(), frappe.session.user, old_route + "%"))
def after_rename(self, old_name, new_name, merge):
if self.route:
invalidate_cache_for_item(self)
clear_cache(self.route)
frappe.db.set_value("Item", new_name, "item_code", new_name)
if merge:
self.set_last_purchase_rate(new_name)
self.recalculate_bin_qty(new_name)
for dt in ("Sales Taxes and Charges", "Purchase Taxes and Charges"):
for d in frappe.db.sql("""select name, item_wise_tax_detail from `tab{0}`
where ifnull(item_wise_tax_detail, '') != ''""".format(dt), as_dict=1):
item_wise_tax_detail = json.loads(d.item_wise_tax_detail)
if old_name in item_wise_tax_detail:
item_wise_tax_detail[new_name] = item_wise_tax_detail[old_name]
item_wise_tax_detail.pop(old_name)
frappe.db.set_value(dt, d.name, "item_wise_tax_detail",
json.dumps(item_wise_tax_detail), update_modified=False)
def migrate(verbose=True, rebuild_website=False):
'''Migrate all apps to the latest version, will:
- run patches
- sync doctypes (schema)
- sync fixtures
- sync desktop icons
- sync web pages (from /www)'''
frappe.flags.in_migrate = True
clear_global_cache()
# run patches
frappe.modules.patch_handler.run_all()
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_fixtures()
sync_customizations()
sync_desktop_icons()
sync_languages()
frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()
# syncs statics
render.clear_cache()
# add static pages to global search
router.sync_global_search()
frappe.db.commit()
if not frappe.conf.get('global_help_setup'):
# sync help if not set as global
frappe.utils.help.sync()
clear_notifications()
frappe.publish_realtime("version-update")
frappe.flags.in_migrate = False
def clear_cache(self): clear_cache(self.get_route())
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("about")
def on_update(self): """clear cache""" frappe.clear_cache(user = '******') from frappe.website.render import clear_cache clear_cache()
(json.dumps(_comments), reference_name))
except Exception, e:
if e.args[0] == 1054 and getattr(frappe.local, 'request', None):
# missing column and in request, add column and update after commit
frappe.local._comments = (
getattr(frappe.local, "_comments", []) +
[(reference_doctype, reference_name, _comments)])
else:
raise ImplicitCommitError
else:
if not frappe.flags.in_patch:
reference_doc = frappe.get_doc(reference_doctype, reference_name)
if getattr(reference_doc, "route", None):
clear_cache(reference_doc.route)
def add_info_comment(**kwargs):
kwargs.update({
"doctype": "Communication",
"communication_type": "Comment",
"comment_type": "Info",
"status": "Closed"
})
return frappe.get_doc(kwargs).insert(ignore_permissions=True)
def update_comments_in_parent_after_request():
"""update _comments in parent if _comments column is missing"""
if hasattr(frappe.local, "_comments"):
def clear_cache(self, name=None):
from frappe.website.render import clear_cache
clear_cache(name or self.name)
if self.parent_website_route:
clear_cache(self.parent_website_route)
def after_rename(self, olddn, newdn, merge):
if getattr(self, "_local"):
self.update_routes_of_descendants(self._local)
clear_cache(self.get_route())
def migrate(verbose=True, rebuild_website=False, skip_failing=False):
'''Migrate all apps to the latest version, will:
- run before migrate hooks
- run patches
- sync doctypes (schema)
- sync fixtures
- sync desktop icons
- sync web pages (from /www)
- sync web pages (from /www)
- run after migrate hooks
'''
touched_tables_file = frappe.get_site_path('touched_tables.json')
if os.path.exists(touched_tables_file):
os.remove(touched_tables_file)
try:
frappe.flags.touched_tables = set()
frappe.flags.in_migrate = True
clear_global_cache()
#run before_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('before_migrate', app_name=app):
frappe.get_attr(fn)()
# run patches
frappe.modules.patch_handler.run_all(skip_failing)
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_jobs()
sync_fixtures()
sync_customizations()
sync_languages()
frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()
# syncs statics
render.clear_cache()
# add static pages to global search
global_search.update_global_search_for_all_web_pages()
#run after_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks('after_migrate', app_name=app):
frappe.get_attr(fn)()
frappe.db.commit()
clear_notifications()
frappe.publish_realtime("version-update")
frappe.flags.in_migrate = False
finally:
with open(touched_tables_file, 'w') as f:
json.dump(list(frappe.flags.touched_tables),
f,
sort_keys=True,
indent=4)
frappe.flags.touched_tables.clear()
def add_comment(comment, comment_email, comment_by, reference_doctype,
reference_name, route):
doc = frappe.get_doc(reference_doctype, reference_name)
if not comment.strip():
frappe.msgprint(_('The comment cannot be empty'))
return False
url_regex = re.compile(
r"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+",
re.IGNORECASE)
email_regex = re.compile(
r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)", re.IGNORECASE)
if url_regex.search(comment) or email_regex.search(comment):
frappe.msgprint(_('Comments cannot have links or email addresses'))
return False
if not comment_email == frappe.session.user:
comment_email = frappe.session.user
comments_count = frappe.db.count(
"Comment", {
"comment_type": "Comment",
"comment_email": frappe.session.user,
"creation": (">", add_to_date(now(), hours=-1))
})
if comments_count > 20:
frappe.msgprint(
_('Hourly comment limit reached for: {0}').format(
frappe.bold(frappe.session.user)))
return False
comment = doc.add_comment(text=comment,
comment_email=comment_email,
comment_by=comment_by)
comment.db_set('published', 1)
# since comments are embedded in the page, clear the web cache
if route:
clear_cache(route)
content = (
comment.content +
"<p><a href='{0}/app/Form/Comment/{1}' style='font-size: 80%'>{2}</a></p>"
.format(frappe.utils.get_request_site_address(), comment.name,
_("View Comment")))
# notify creator
frappe.sendmail(recipients=frappe.db.get_value('User', doc.owner, 'email')
or doc.owner,
subject=_('New Comment on {0}: {1}').format(
doc.doctype, doc.name),
message=content,
reference_doctype=doc.doctype,
reference_name=doc.name)
# revert with template if all clear (no backlinks)
template = frappe.get_template("templates/includes/comments/comment.html")
return template.render({"comment": comment.as_dict()})
def on_update(self):
super(BlogPost, self).on_update()
clear_cache("writers")
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("blog")
clear_cache("writers")
def on_update(self):
clear_cache(self.get_route())
if getattr(self, "save_versions", False):
frappe.add_version(self)
def clear_cache(self): super(WebsiteGenerator, self).clear_cache() clear_cache(self.route)
def on_update(self):
# make js and css
# clear web cache (for menus!)
from frappe.website.render import clear_cache
clear_cache()
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("contact")
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("landingrequest")
def on_update(self):
clear_cache("writers")
def on_update(self):
# a slide show can be in use and any change in it should get reflected
from frappe.website.render import clear_cache
clear_cache()
def clear_blog_cache():
for blog in frappe.db.sql_list("""select page_name from
`tabBlog Post` where ifnull(published,0)=1"""):
clear_cache(blog)
clear_cache("writers")
def before_rename(self, oldname, name, merge):
self._local = self.get_route()
clear_cache(self.get_route())
def on_update(self):
WebsiteGenerator.on_update(self)
clear_cache("writers")
(json.dumps(_comments), reference_name))
except Exception, e:
if e.args[0] == 1054 and frappe.local.request:
# missing column and in request, add column and update after commit
frappe.local._comments = (
getattr(frappe.local, "_comments", []) +
[(reference_doctype, reference_name, _comments)])
else:
raise
else:
reference_doc = frappe.get_doc(reference_doctype, reference_name)
if getattr(reference_doc, "get_route", None):
clear_cache(reference_doc.get_route())
def add_info_comment(**kwargs):
kwargs.update({
"doctype": "Communication",
"communication_type": "Comment",
"comment_type": "Info"
})
return frappe.get_doc(kwargs).insert(ignore_permissions=True)
def update_comments_in_parent_after_request():
"""update _comments in parent if _comments column is missing"""
if hasattr(frappe.local, "_comments"):
for (reference_doctype, reference_name,
def add_comment(args=None):
"""
args = {
'comment': '',
'comment_by': '',
'comment_by_fullname': '',
'reference_doctype': '',
'reference_name': '',
'route': '',
}
"""
if not args:
args = frappe.local.form_dict
route = args.get("route")
doc = frappe.get_doc(args["reference_doctype"], args["reference_name"])
comment = doc.add_comment("Comment",
args["comment"],
comment_by=args["comment_by"])
comment.flags.ignore_permissions = True
comment.sender_full_name = args["comment_by_fullname"]
comment.save()
# since comments are embedded in the page, clear the web cache
clear_cache(route)
# notify commentors
commentors = [
d[0] for d in frappe.db.sql(
"""select sender from `tabCommunication`
where
communication_type = 'Comment' and comment_type = 'Comment'
and reference_doctype=%s
and reference_name=%s""", (comment.reference_doctype,
comment.reference_name))
]
owner = frappe.db.get_value(doc.doctype, doc.name, "owner")
recipients = list(
set(commentors if owner == "Administrator" else (commentors +
[owner])))
message = _("{0} by {1}").format(
frappe.utils.markdown(args.get("comment")), comment.sender_full_name)
message += "<p><a href='{0}/{1}' style='font-size: 80%'>{2}</a></p>".format(
frappe.utils.get_request_site_address(), route,
_("View it in your browser"))
from frappe.email.queue import send
send(recipients=recipients,
subject=_("New comment on {0} {1}").format(doc.doctype, doc.name),
message=message,
reference_doctype=doc.doctype,
reference_name=doc.name)
template = frappe.get_template("templates/includes/comments/comment.html")
return template.render({"comment": comment.as_dict()})
def add_comment(args=None):
"""
args = {
'comment': '',
'comment_by': '',
'comment_by_fullname': '',
'comment_doctype': '',
'comment_docname': '',
'page_name': '',
}
"""
if not args:
args = frappe.local.form_dict
args['doctype'] = "Comment"
page_name = args.get("page_name")
if "page_name" in args:
del args["page_name"]
if "cmd" in args:
del args["cmd"]
comment = frappe.get_doc(args)
comment.comment_type = "Comment"
comment.flags.ignore_permissions = True
comment.insert()
# since comments are embedded in the page, clear the web cache
clear_cache(page_name)
# notify commentors
commentors = [
d[0] for d in frappe.db.sql(
"""select comment_by from tabComment where
comment_doctype=%s and comment_docname=%s and
unsubscribed=0""", (comment.comment_doctype, comment.comment_docname))
]
owner = frappe.db.get_value(comment.comment_doctype,
comment.comment_docname, "owner")
recipients = list(
set(commentors if owner == "Administrator" else (commentors +
[owner])))
message = _("{0} by {1}").format(markdown2.markdown(args.get("comment")),
comment.comment_by_fullname)
message += "<p><a href='{0}/{1}' style='font-size: 80%'>{2}</a></p>".format(
frappe.utils.get_request_site_address(), page_name,
_("View it in your browser"))
from frappe.email.bulk import send
send(recipients=recipients,
subject=_("New comment on {0} {1}").format(comment.comment_doctype,
comment.comment_docname),
message=message,
reference_doctype=comment.comment_doctype,
reference_name=comment.comment_docname)
template = frappe.get_template("templates/includes/comments/comment.html")
return template.render({"comment": comment.as_dict()})
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("project-progress")
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("media")
def clear_cache(self):
clear_cache(self.route)
def on_update(self): clear_cache(self.get_route()) if getattr(self, "save_versions", False): frappe.add_version(self)
def on_update(self):
self.update_category()
clear_cache()
def migrate(verbose=True, skip_failing=False, skip_search_index=False):
"""Migrate all apps to the current version, will:
- run before migrate hooks
- run patches
- sync doctypes (schema)
- sync dashboards
- sync fixtures
- sync desktop icons
- sync web pages (from /www)
- sync web pages (from /www)
- run after migrate hooks
"""
service_status = check_connection(redis_services=["redis_cache"])
if False in service_status.values():
for service in service_status:
if not service_status.get(service, True):
print("{} service is not running.".format(service))
print("""Cannot run bench migrate without the services running.
If you are running bench in development mode, make sure that bench is running:
$ bench start
Otherwise, check the server logs and ensure that all the required services are running."""
)
sys.exit(1)
touched_tables_file = frappe.get_site_path("touched_tables.json")
if os.path.exists(touched_tables_file):
os.remove(touched_tables_file)
try:
add_column(doctype="DocType",
column_name="migration_hash",
fieldtype="Data")
frappe.flags.touched_tables = set()
frappe.flags.in_migrate = True
clear_global_cache()
# run before_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks("before_migrate", app_name=app):
frappe.get_attr(fn)()
# run patches
frappe.modules.patch_handler.run_all(skip_failing)
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_jobs()
sync_fixtures()
sync_dashboards()
sync_customizations()
sync_languages()
frappe.get_doc("Portal Settings", "Portal Settings").sync_menu()
# syncs statics
render.clear_cache()
# updating installed applications data
frappe.get_single("Installed Applications").update_versions()
# run after_migrate hooks
for app in frappe.get_installed_apps():
for fn in frappe.get_hooks("after_migrate", app_name=app):
frappe.get_attr(fn)()
# build web_routes index
if not skip_search_index:
# Run this last as it updates the current session
print("Building search index for {}".format(frappe.local.site))
build_index_for_all_routes()
frappe.db.commit()
clear_notifications()
frappe.publish_realtime("version-update")
frappe.flags.in_migrate = False
finally:
with open(touched_tables_file, "w") as f:
json.dump(list(frappe.flags.touched_tables),
f,
sort_keys=True,
indent=4)
frappe.flags.touched_tables.clear()
def clear_cache():
clear_website_cache()
from frappe.website.render import clear_cache
clear_cache()
def clear_cache(self):
clear_cache(self.get_route())
def on_update(self):
from frappe.website.render import clear_cache
clear_cache("aboutus")
def on_update(self): clear_cache()
def on_trash(self):
clear_cache(self.get_route())