def login_feed(login_manager):
frappe.get_doc({
"doctype": "Feed",
"feed_type": "Login",
"subject": _("{0} logged in").format(get_fullname(login_manager.user)),
"full_name": get_fullname(login_manager.user)
}).insert(ignore_permissions=True)
def validate(self):
if self.is_new():
self.add_assign_comment(frappe._("Assigned to {0}: {1}").format(get_fullname(self.owner), self.description), "Assigned")
else:
cur_status = frappe.db.get_value("ToDo", self.name, "status")
if cur_status != self.status:
self.add_assign_comment(frappe._("Assignment closed by {0}".format(get_fullname(frappe.session.user))),
"Assignment Completed")
def validate(self):
if self.is_new():
self.add_assign_comment(frappe._("Assigned to {0}: {1}").format(get_fullname(self.owner), self.description), "Assigned")
else:
# NOTE the previous value is only available in validate method
if self.get_db_value("status") != self.status:
self.add_assign_comment(frappe._("Assignment closed by {0}".format(get_fullname(frappe.session.user))),
"Assignment Completed")
def after_insert(self):
doc = self.get_doc()
owner = get_fullname(self.owner)
if self.everyone:
doc.add_comment("Shared", _("{0} shared this document with everyone").format(owner))
else:
doc.add_comment("Shared", _("{0} shared this document with {1}").format(owner, get_fullname(self.user)))
def on_update(self):
from frappe.templates.website_group.post import clear_post_cache
from frappe.website.doctype.website_group.website_group import clear_cache
clear_cache(website_group=self.website_group)
clear_post_cache(self.parent_post or self.name)
if self.assigned_to and self.assigned_to != self.assigned_to \
and frappe.session.user != self.assigned_to:
# send assignment email
sendmail(recipients=[self.assigned_to],
subject="You have been assigned this Task by {}".format(get_fullname(self.modified_by)),
msg=self.get_reply_email_message(self.name, get_fullname(self.owner)))
def get_context(self, context):
# this is for double precaution. usually it wont reach this code if not published
if not cint(self.published):
raise Exception, "This blog has not been published yet!"
# temp fields
context.full_name = get_fullname(self.owner)
context.updated = global_date_format(self.published_on)
if self.blogger:
context.blogger_info = frappe.get_doc("Blogger", self.blogger).as_dict()
context.description = self.blog_intro or self.content[:140]
context.metatags = {
"name": self.title,
"description": context.description,
}
image = find_first_image(self.content)
if image:
context.metatags["image"] = image
context.categories = frappe.db.sql_list("""select name from
`tabBlog Category` order by name""")
context.comment_list = get_comment_list(self.doctype, self.name)
context.children = get_children()
return context
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if not (self.lead or self.customer):
lead_name = frappe.db.get_value("Lead", {"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
account = _('Unknown')
if self.contact_email.index('@'):
email_name = self.contact_email[0:self.contact_email.index('@')]
email_split = email_name.split('.')
for s in email_split:
account = account + s.capitalize() + ' '
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name or account
})
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.enquiry_from = "Lead"
self.lead = lead_name
def get_context(context):
blog_post = context.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.get_doc("Blogger", blog_post.blogger).as_dict()
blog_post.description = blog_post.blog_intro or blog_post.content[:140]
blog_post.metatags = {
"name": blog_post.title,
"description": blog_post.description,
}
image = find_first_image(blog_post.content)
if image:
blog_post.metatags["image"] = image
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.__dict__
def notify(arg=None):
from frappe.utils import cstr, get_fullname, get_url
try:
frappe.sendmail(\
recipients=[frappe.db.get_value("User", arg["contact"], "email") or arg["contact"]],
sender= frappe.db.get_value("User", frappe.session.user, "email"),
subject="New Message from " + get_fullname(frappe.user.name),
message=frappe.get_template("templates/emails/new_message.html").render({
"from": get_fullname(frappe.user.name),
"message": arg['txt'],
"link": get_url()
})
)
except frappe.OutgoingEmailError, e:
pass
def get_todo_list(self, user_id):
todo_list = frappe.db.sql(
"""select *
from `tabToDo` where (owner=%s or assigned_by=%s)
order by field(priority, 'High', 'Medium', 'Low') asc, date asc""",
(user_id, user_id),
as_dict=True,
)
html = ""
if todo_list:
for i, todo in enumerate([todo for todo in todo_list if not todo.checked]):
if i >= 10:
break
if not todo.description and todo.reference_type:
todo.description = "%s: %s - %s %s" % (
todo.reference_type,
get_url_to_form(todo.reference_type, todo.reference_name),
_("assigned by"),
get_fullname(todo.assigned_by),
)
html += "<li style='line-height: 200%%'>%s [%s]</li>" % (todo.description, todo.priority)
if html:
return 1, "<h4>To Do (max 10):</h4><ul>" + html + "</ul><hr>"
else:
return 0, "<p>To Do</p>"
def daily_notifications():
"""
sent notifications to user if
1 : ticket is open for more than 24 hrs
2 : ticket is assigned but not Closed in 24 hrs
"""
tickets = frappe.db.get_all("Ticket Escalation History", filters=[["status", "!=", "Closed"], ["status", "!=", "Deleted"]], fields=["*"])
for ticket in tickets:
# ticket is raised but not yet assigned
issue_doc = frappe.get_doc("Issue", ticket.ticket_id)
args = {
"user": get_fullname(issue_doc.raised_by) or "User",
"email": issue_doc.raised_by,
"action": "user_issue_notification",
"issue": issue_doc
}
if ticket.raised_email_notification and not ticket.assigned_email_notification:
raised_time = ticket.raised_email_notification_datetime
if time_diff_in_hours(get_datetime().now(), raised_time) >= 24:
# send user notification mail
msg = "Your support ticket {ticket_id} is pending our representative will \
check the issue as soon as possible".format(ticket_id=ticket.ticket_id)
args.update({"msg":msg})
send_mail(args, "[HelpDesk] Daily Notifications")
elif ticket.assigned_email_notification and not ticket.status_closed_email_notification:
assigned_time = ticket.assigned_email_notification_datetime
if time_diff_in_hours(get_datetime().now(), assigned_time) >= 24:
# send the user notification mail
msg = "Your support ticket {ticket_id} is assigned to our support representative \
and issue will be solved as soon as possble".format(ticket_id=ticket.ticket_id)
args.update({"msg":msg})
send_mail(args, "[HelpDesk] Daily Notifications")
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if not (self.lead or self.customer) and self.contact_email:
lead_name = frappe.db.get_value("Lead", {"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
if not sender_name and ('@' in self.contact_email):
email_name = self.contact_email.split('@')[0]
email_split = email_name.split('.')
sender_name = ''
for s in email_split:
sender_name += s.capitalize() + ' '
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name
})
lead.flags.ignore_email_validation = True
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.enquiry_from = "Lead"
self.lead = lead_name
def get_context(self, context):
# this is for double precaution. usually it wont reach this code if not published
if not cint(self.published):
raise Exception, "This blog has not been published yet!"
# temp fields
context.full_name = get_fullname(self.owner)
context.updated = global_date_format(self.published_on)
if self.blogger:
context.blogger_info = frappe.get_doc("Blogger", self.blogger).as_dict()
context.description = self.blog_intro or self.content[:140]
context.metatags = {
"name": self.title,
"description": context.description,
}
if "<!-- markdown -->" in context.content:
context.content = markdown(context.content)
image = find_first_image(self.content)
if image:
context.metatags["image"] = image
context.comment_list = get_comment_list(self.doctype, self.name)
context.children = get_children()
category = frappe.db.get_value("Blog Category", context.doc.blog_category, ["title", "page_name"], as_dict=1)
context.parents = [{"title": category.title, "name": "blog/{0}".format(category.page_name)}]
def validate_leave_approver(self):
employee = frappe.get_doc("Employee", self.employee)
leave_approvers = [l.leave_approver for l in employee.get("leave_approvers")]
if len(leave_approvers) and self.leave_approver not in leave_approvers:
frappe.throw(
_("Leave approver must be one of {0}").format(comma_or(leave_approvers)), InvalidLeaveApproverError
)
elif self.leave_approver and not frappe.db.sql(
"""select name from `tabUserRole`
where parent=%s and role='Leave Approver'""",
self.leave_approver,
):
frappe.throw(
_("{0} ({1}) must have role 'Leave Approver'").format(
get_fullname(self.leave_approver), self.leave_approver
),
InvalidLeaveApproverError,
)
elif self.docstatus == 1 and len(leave_approvers) and self.leave_approver != frappe.session.user:
frappe.throw(
_("Only the selected Leave Approver can submit this Leave Application"), LeaveApproverIdentityError
)
def update_feed(doc, method=None):
"adds a new feed"
if frappe.flags.in_patch or frappe.flags.in_install or frappe.flags.in_import:
return
if doc.doctype == "Feed":
return
if hasattr(doc, "get_feed"):
feed = doc.get_feed()
if feed:
if isinstance(feed, basestring):
feed = {"subject": feed}
feed = frappe._dict(feed)
doctype = feed.doctype or doc.doctype
name = feed.name or doc.name
# delete earlier feed
frappe.db.sql("""delete from tabFeed
where doc_type=%s and doc_name=%s
and ifnull(feed_type,'')=''""", (doctype, name))
frappe.get_doc({
"doctype": "Feed",
"feed_type": feed.feed_type or "",
"doc_type": doctype,
"doc_name": name,
"subject": feed.subject,
"full_name": get_fullname(doc.owner)
}).insert(ignore_permissions=True)
def get_customer(user=None):
if not user:
user = frappe.session.user
customer = frappe.db.get_value("Contact", {"email_id": user}, "customer")
if customer:
return frappe.get_doc("Customer", customer)
else:
customer = frappe.new_doc("Customer")
fullname = get_fullname(user)
customer.update({
"customer_name": fullname,
"customer_type": "Individual",
"customer_group": get_shopping_cart_settings().default_customer_group,
"territory": get_root_of("Territory")
})
customer.insert(ignore_permissions=True)
contact = frappe.new_doc("Contact")
contact.update({
"customer": customer.name,
"first_name": fullname,
"email_id": user
})
contact.insert(ignore_permissions=True)
return customer
def notify_mentions(doc):
if doc.communication_type != "Comment":
return
if doc.reference_doctype and doc.reference_name and doc.content and doc.comment_type=="Comment":
mentions = extract_mentions(doc.content)
if not mentions:
return
sender_fullname = get_fullname(frappe.session.user)
parent_doc_label = "{0} {1}".format(_(doc.reference_doctype), doc.reference_name)
subject = _("{0} mentioned you in a comment in {1}").format(sender_fullname, parent_doc_label)
message = frappe.get_template("templates/emails/mentioned_in_comment.html").render({
"sender_fullname": sender_fullname,
"comment": doc,
"link": get_link_to_form(doc.reference_doctype, doc.reference_name, label=parent_doc_label)
})
recipients = [frappe.db.get_value("User", {"enabled": 1, "username": username, "user_type": "System User"})
for username in mentions]
frappe.sendmail(
recipients=recipients,
sender=frappe.session.user,
subject=subject,
message=message,
bulk=True
)
def validate_expense_approver(self):
if self.exp_approver and "Expense Approver" not in frappe.get_roles(self.exp_approver):
frappe.throw(
_("{0} ({1}) must have role 'Expense Approver'").format(
get_fullname(self.exp_approver), self.exp_approver
),
InvalidExpenseApproverError,
)
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = self.sender
self.sender = frappe.db.get_value("User", "Administrator", "email")
else:
validate_email_add(self.sender, throw=True)
self.sender_full_name = get_fullname(self.sender)
def _notify(contact, txt, subject=None):
from frappe.utils import get_fullname, get_url
try:
if not isinstance(contact, list):
contact = [frappe.db.get_value("User", contact, "email") or contact]
frappe.sendmail(\
recipients=contact,
sender= frappe.db.get_value("User", frappe.session.user, "email"),
subject=subject or "New Message from " + get_fullname(frappe.session.user),
message=frappe.get_template("templates/emails/new_message.html").render({
"from": get_fullname(frappe.session.user),
"message": txt,
"link": get_url()
}))
except frappe.OutgoingEmailError:
pass
def on_trash(self):
if not self.flags.ignore_share_permission:
self.check_share_permission()
self.get_doc().add_comment(
"Unshared",
_("{0} un-shared this document with {1}").format(get_fullname(self.owner), get_fullname(self.user)),
)
def validate(self):
"""Raise exception for more than 50 comments."""
if frappe.db.sql("""select count(*) from tabComment where comment_doctype=%s
and comment_docname=%s""", (self.doctype, self.name))[0][0] >= 50:
frappe.throw(_("Cannot add more than 50 comments"))
if not self.comment_by_fullname and self.comment_by:
self.comment_by_fullname = get_fullname(self.comment_by)
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
}
def get_party(user=None):
if not user:
user = frappe.session.user
contact_name = frappe.db.get_value("Contact", {"email_id": user})
party = None
if contact_name:
contact = frappe.get_doc('Contact', contact_name)
if contact.links:
party_doctype = contact.links[0].link_doctype
party = contact.links[0].link_name
cart_settings = frappe.get_doc("Shopping Cart Settings")
debtors_account = ''
if cart_settings.enable_checkout:
debtors_account = get_debtors_account(cart_settings)
if party:
return frappe.get_doc(party_doctype, party)
else:
if not cart_settings.enabled:
frappe.local.flags.redirect_location = "/contact"
raise frappe.Redirect
customer = frappe.new_doc("Customer")
fullname = get_fullname(user)
customer.update({
"customer_name": fullname,
"customer_type": "Individual",
"customer_group": get_shopping_cart_settings().default_customer_group,
"territory": get_root_of("Territory")
})
if debtors_account:
customer.update({
"accounts": [{
"company": cart_settings.company,
"account": debtors_account
}]
})
customer.flags.ignore_mandatory = True
customer.insert(ignore_permissions=True)
contact = frappe.new_doc("Contact")
contact.update({
"first_name": fullname,
"email_id": user
})
contact.append('links', dict(link_doctype='Customer', link_name=customer.name))
contact.flags.ignore_mandatory = True
contact.insert(ignore_permissions=True)
return customer
def execute():
for user_id in frappe.db.sql_list("""select distinct user_id from `tabEmployee`
where ifnull(user_id, '')!=''
group by user_id having count(name) > 1"""):
fullname = get_fullname(user_id)
employee = frappe.db.get_value("Employee", {"employee_name": fullname, "user_id": user_id})
if employee:
frappe.db.sql("""update `tabEmployee` set user_id=null
where user_id=%s and name!=%s""", (user_id, employee))
def get_user_details(user):
from frappe.utils import get_fullname
# fields = ["city", "building", "area", "facility", "description"]
details = frappe.db.get_value("User", user, as_dict=True)
if details:
details.update({"user_fullname":get_fullname(user) or ""})
return details
else:
return {}
def get_user_details(user):
from frappe.utils import get_fullname
fields = ["floor", "extension_number", "wing", "cabin_or_workstation_number", "department"]
details = frappe.db.get_value("User", user, fields, as_dict=True)
if details:
details.update({"user_fullname":get_fullname(user) or ""})
return details
else:
return {}
def _notify(contact, txt, subject=None):
from frappe.utils import get_fullname, get_url
try:
if not isinstance(contact, list):
contact = [frappe.db.get_value("User", contact, "email") or contact]
frappe.sendmail(\
recipients=contact,
sender= frappe.db.get_value("User", frappe.session.user, "email"),
subject=subject or _("New Message from {0}").format(get_fullname(frappe.session.user)),
template="new_message",
args={
"from": get_fullname(frappe.session.user),
"message": txt,
"link": get_url()
},
header=[_('New Message'), 'orange'])
except frappe.OutgoingEmailError:
pass
def get_context(context):
data = frappe.db.sql("""select count(*) as translated, modified_by
from `tabTranslated Message`
where modified_by != "Administrator"
group by modified_by order by translated desc limit 20""", as_dict=1)
for d in data:
d.fullname = get_fullname(d.modified_by)
context.users = data
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = self.sender
self.sender = frappe.db.get_value("User", "Administrator", "email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parseaddr(self.sender)
if not sender_name:
sender_name = get_fullname(sender_email)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or get_fullname(frappe.session.user)
def _notify(args):
from frappe.utils import get_fullname, get_url
args = frappe._dict(args)
contact = args.contact
txt = args.txt
try:
if not isinstance(contact, list):
contact = [frappe.db.get_value("User", contact, "email") or contact]
frappe.sendmail(\
recipients=contact,
sender= frappe.db.get_value("User", frappe.session.user, "email"),
subject=_("New message from {0}").format(get_fullname(frappe.session.user)),
template="new_message",
args={
"from": get_fullname(frappe.session.user),
"message": txt,
"link": get_url()
},
header=[_('New Message'), 'orange'])
except frappe.OutgoingEmailError:
pass
def set_title(self):
"""Set default title for the Time Log"""
if self.title:
return
from frappe.utils import get_fullname
if self.production_order:
self.title = _("{0} for {1}").format(self.operation,
self.production_order)
elif self.activity_type and (self.task or self.project):
self.title = _("{0} for {1}").format(self.activity_type, self.task
or self.project)
else:
self.title = self.task or self.project or get_fullname(
frappe.session.user)
def send_email_on_reply(self):
owner_fullname = get_fullname(self.owner)
parent_post = frappe.get_doc("Post", self.parent_post)
message = self.get_reply_email_message(self.name, owner_fullname)
# send email to the owner of the post, if he/she is different
if parent_post.owner != self.owner:
send(recipients=[parent_post.owner],
subject="{someone} replied to your post".format(someone=owner_fullname),
message=message,
# to allow unsubscribe
doctype='Post',
email_field='owner',
# for tracking sent status
ref_doctype=self.doctype, ref_docname=self.name)
# send email to members who part of the conversation
participants = frappe.db.sql("""select owner, name from `tabPost`
where parent_post=%s and owner not in (%s, %s) order by creation asc""",
(self.parent_post, parent_post.owner, self.owner), as_dict=True)
send(recipients=[p.owner for p in participants],
subject="{someone} replied to a post by {other}".format(someone=owner_fullname,
other=get_fullname(parent_post.owner)),
message=message,
# to allow unsubscribe
doctype='Post',
email_field='owner',
# for tracking sent status
ref_doctype=self.doctype, ref_docname=self.name)
def execute():
for user_id in frappe.db.sql_list("""select distinct user_id from `tabEmployee`
where ifnull(user_id, '')!=''
group by user_id having count(name) > 1"""):
fullname = get_fullname(user_id)
employee = frappe.db.get_value("Employee", {"employee_name": fullname, "user_id": user_id})
if employee:
frappe.db.sql("""update `tabEmployee` set user_id=null
where user_id=%s and name!=%s""", (user_id, employee))
else:
count = frappe.db.sql("""select count(*) from `tabEmployee` where user_id=%s""", user_id)[0][0]
frappe.db.sql("""update `tabEmployee` set user_id=null
where user_id=%s limit %s""", (user_id, count - 1))
def get_context(context):
context.no_cache = True
data = frappe.db.sql("""SELECT count(*) AS contribution_count, modified_by
FROM `tabTranslated Message`
WHERE modified_by != "Administrator"
GROUP BY modified_by
ORDER BY contribution_count
DESC LIMIT 50
""",
as_dict=1)
for d in data:
d.fullname = get_fullname(d.modified_by)
context.users = data
def insert_feed(doc):
from frappe.utils import get_fullname
if frappe.flags.in_install or frappe.flags.in_import or getattr(
doc, "no_feed_on_delete", False):
return
frappe.get_doc({
"doctype": "Feed",
"feed_type": "Label",
"doc_type": doc.doctype,
"doc_name": doc.name,
"subject": _("Deleted"),
"full_name": get_fullname(doc.owner)
}).insert(ignore_permissions=True)
def validate_leave_approver(self):
employee = frappe.get_doc("Employee", self.employee)
leave_approvers = [l.leave_approver for l in employee.get("employee_leave_approvers")]
if len(leave_approvers) and self.leave_approver not in leave_approvers:
frappe.throw(_("Leave approver must be one of {0}").format(comma_or(leave_approvers)), InvalidLeaveApproverError)
elif self.leave_approver and not frappe.db.sql("""select name from `tabUserRole`
where parent=%s and role='Leave Approver'""", self.leave_approver):
frappe.throw(_("{0} ({1}) must have role 'Leave Approver'")\
.format(get_fullname(self.leave_approver), self.leave_approver), InvalidLeaveApproverError)
elif self.docstatus==1 and len(leave_approvers) and self.leave_approver != frappe.session.user:
msgprint(_("Only the selected Leave Approver can submit this Leave Application"),
raise_exception=LeaveApproverIdentityError)
def insert_feed(doc):
from frappe.utils import get_fullname
if frappe.flags.in_install or frappe.flags.in_import or getattr(
doc, "no_feed_on_delete", False):
return
frappe.get_doc({
"doctype": "Communication",
"communication_type": "Comment",
"comment_type": "Deleted",
"reference_doctype": doc.doctype,
"subject": "{0} {1}".format(_(doc.doctype), doc.name),
"full_name": get_fullname(doc.owner)
}).insert(ignore_permissions=True)
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if not (self.lead or self.customer) and self.contact_email:
# check if customer is already created agains the self.contact_email
customer = frappe.db.sql("""select
distinct `tabDynamic Link`.link_name as customer
from
`tabContact`,
`tabDynamic Link`
where `tabContact`.email_id='{0}'
and
`tabContact`.name=`tabDynamic Link`.parent
and
ifnull(`tabDynamic Link`.link_name, '')<>''
and
`tabDynamic Link`.link_doctype='Customer'
""".format(self.contact_email), as_dict=True)
if customer and customer[0].customer:
self.customer = customer[0].customer
self.enquiry_from = "Customer"
return
lead_name = frappe.db.get_value("Lead", {"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
if not sender_name and ('@' in self.contact_email):
email_name = self.contact_email.split('@')[0]
email_split = email_name.split('.')
sender_name = ''
for s in email_split:
sender_name += s.capitalize() + ' '
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name or 'Unknown'
})
lead.flags.ignore_email_validation = True
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.enquiry_from = "Lead"
self.lead = lead_name
def info(_w_appid, _w_access_key, _w_conf_name, _w_conf_version,
_w_conf_version_new, _w_signature):
valid_auth_code(_w_access_key)
_w_conf_name = _w_conf_name or frappe.get_request_header(
"x-weboffice-file-id")
conf_doc = frappe.get_doc("IOT Application Conf", _w_conf_name)
if conf_doc.public == 0 and conf_doc.developer != frappe.session.user:
throw("has_no_permission")
data = app_conf_data(conf_doc.name, _w_conf_version)
creation = get_datetime(conf_doc.creation)
modified = get_datetime((conf_doc.modified))
params = "_w_appid=" + _w_appid + "&_w_conf_name=" + _w_conf_name + "&_w_conf_version=" + _w_conf_version + \
"&_w_conf_version_new=" + _w_conf_version_new + "&_w_access_key=" + _w_access_key
file_info = {
"id":
_w_conf_name,
"name":
conf_doc.app + "-" + conf_doc.name + ".csv",
"version":
int(_w_conf_version_new),
"size":
len(data.get('data') or ''),
"creator":
conf_doc.owner,
"create_time":
int(creation.timestamp()),
"modifier":
conf_doc.developer,
"modify_time":
int(modified.timestamp()),
"download_url":
"https://cloud.thingsroot.com/v1/3rd/file/content?" + params
}
user_info = {
"id":
frappe.session.user,
"name":
get_fullname(frappe.session.user),
"permission":
"write" if conf_doc.developer == frappe.session.user else "read"
}
frappe.response.update({"file": file_info, "user": user_info})
def get_context(self, context):
# this is for double precaution. usually it wont reach this code if not published
if not cint(self.published):
raise Exception("This blog has not been published yet!")
context.no_breadcrumbs = True
# temp fields
context.full_name = get_fullname(self.owner)
context.updated = global_date_format(self.published_on)
context.social_links = self.fetch_social_links_info()
context.cta = self.fetch_cta()
context.enable_cta = not self.hide_cta and frappe.db.get_single_value(
"Blog Settings", "show_cta_in_blog", cache=True
)
if self.blogger:
context.blogger_info = frappe.get_doc("Blogger", self.blogger).as_dict()
context.author = self.blogger
context.content = get_html_content_based_on_type(self, "content", self.content_type)
# if meta description is not present, then blog intro or first 140 characters of the blog will be set as description
context.description = (
self.meta_description or self.blog_intro or strip_html_tags(context.content[:140])
)
context.metatags = {
"name": self.meta_title,
"description": context.description,
}
# if meta image is not present, then first image inside the blog will be set as the meta image
image = find_first_image(context.content)
context.metatags["image"] = self.meta_image or image or None
self.load_comments(context)
self.load_feedback(context)
context.category = frappe.db.get_value(
"Blog Category", context.doc.blog_category, ["title", "route"], as_dict=1
)
context.parents = [
{"name": _("Home"), "route": "/"},
{"name": "Blog", "route": "/blog"},
{"label": context.category.title, "route": context.category.route},
]
context.guest_allowed = True
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = frappe.db.get_value("User", "Administrator", "full_name")
self.sender = frappe.db.get_value("User", "Administrator", "email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
if self.sent_or_received=='Sent':
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parse_addr(self.sender)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or get_fullname(frappe.session.user) if frappe.session.user!='Administrator' else None
def get_context(self, context):
# this is for double precaution. usually it wont reach this code if not published
if not cint(self.published):
raise Exception, "This blog has not been published yet!"
# temp fields
context.full_name = get_fullname(self.owner)
context.updated = global_date_format(self.published_on)
if self.blogger:
context.blogger_info = frappe.get_doc("Blogger",
self.blogger).as_dict()
context.description = self.blog_intro or self.content[:140]
context.metatags = {
"name": self.title,
"description": context.description,
}
if "<!-- markdown -->" in context.content:
context.content = markdown(context.content)
image = find_first_image(self.content)
if image:
context.metatags["image"] = image
context.comment_list = get_comment_list(self.doctype, self.name)
if not context.comment_list:
context.comment_text = _('No comments yet')
else:
if (len(context.comment_list)) == 1:
context.comment_text = _('1 comment')
else:
context.comment_text = _('{0} comments').format(
len(context.comment_list))
context.children = get_children()
category = frappe.db.get_value("Blog Category",
context.doc.blog_category,
["title", "page_name"],
as_dict=1)
context.parents = [{
"title": category.title,
"name": "blog/{0}".format(category.page_name)
}]
def get_customer(user=None):
if not user:
user = frappe.session.user
customer = frappe.db.get_value("Contact", {"email_id": user}, "customer")
cart_settings = frappe.get_doc("Shopping Cart Settings")
debtors_account = ''
if cart_settings.enable_checkout:
debtors_account = get_debtors_account(cart_settings)
if customer:
return frappe.get_doc("Customer", customer)
else:
customer = frappe.new_doc("Customer")
fullname = get_fullname(user)
customer.update({
"customer_name": fullname,
"customer_type": "Individual",
"customer_group":
get_shopping_cart_settings().default_customer_group,
"territory": get_root_of("Territory")
})
if debtors_account:
customer.update({
"accounts": [{
"company": cart_settings.company,
"account": debtors_account
}]
})
customer.flags.ignore_mandatory = True
customer.insert(ignore_permissions=True)
contact = frappe.new_doc("Contact")
contact.update({
"customer": customer.name,
"first_name": fullname,
"email_id": user
})
contact.flags.ignore_mandatory = True
contact.insert(ignore_permissions=True)
return customer
def randomly_assign(docs):
from frappe.desk.form.assign_to import add
# USAGE
#
# args = {
# "assign_to": ,
# "doctype": ,
# "name": ,
# "description":
# }
if isinstance(docs, basestring):
import json
docs = json.loads(docs)
from frappe import get_all, bold, _
collector_users = [d.user for d in \
get_all("Case Record Settings User",
fields=["user"])]
import random
random.shuffle(collector_users)
length = len(collector_users)
idx = 0
from frappe.utils import cint, get_fullname
for doctype, name in docs:
random.shuffle(collector_users)
collector_user = collector_users[cint((idx + length)**length % length)]
add({
"assign_to": collector_user,
"doctype": doctype,
"name": name,
"description": _("Randomly assigned by {}" \
.format(bold(get_fullname())))
})
idx += 1
def update_feed(doc, method=None):
if frappe.flags.in_patch or frappe.flags.in_install or frappe.flags.in_import:
return
if doc._action != "save" or doc.flags.ignore_feed:
return
if doc.doctype == "Activity Log" or doc.meta.issingle:
return
if hasattr(doc, "get_feed"):
feed = doc.get_feed()
if feed:
if isinstance(feed, string_types):
feed = {"subject": feed}
feed = frappe._dict(feed)
doctype = feed.doctype or doc.doctype
name = feed.name or doc.name
# delete earlier feed
frappe.db.sql(
"""delete from `tabActivity Log`
where
reference_doctype=%s and reference_name=%s
and link_doctype=%s""", (doctype, name, feed.link_doctype))
frappe.get_doc({
"doctype":
"Activity Log",
"reference_doctype":
doctype,
"reference_name":
name,
"subject":
feed.subject,
"full_name":
get_fullname(doc.owner),
"reference_owner":
frappe.db.get_value(doctype, name, "owner"),
"link_doctype":
feed.link_doctype,
"link_name":
feed.link_name
}).insert(ignore_permissions=True)
def update_feed(doc, method=None):
"adds a new feed"
if frappe.flags.in_patch or frappe.flags.in_install or frappe.flags.in_import:
return
if doc.doctype == "Feed" or doc.meta.issingle:
return
if hasattr(doc, "get_feed"):
feed = doc.get_feed()
if feed:
if isinstance(feed, basestring):
feed = {"subject": feed}
feed = frappe._dict(feed)
doctype = feed.doctype or doc.doctype
name = feed.name or doc.name
# delete earlier feed
frappe.db.sql(
"""delete from tabFeed
where doc_type=%s and doc_name=%s
and ifnull(feed_type,'')=''""", (doctype, name))
frappe.get_doc({
"doctype":
"Feed",
"feed_type":
feed.feed_type or "",
"doc_type":
doctype,
"doc_name":
name,
"subject":
feed.subject,
"full_name":
get_fullname(doc.owner),
"doc_owner":
frappe.db.get_value(doctype, name, "owner"),
"reference_doctype":
feed.reference_doctype,
"reference_name":
feed.reference_name
}).insert(ignore_permissions=True)
def get_upgrade_url(upgrade_url):
parts = urlparse.urlsplit(upgrade_url)
params = dict(urlparse.parse_qsl(parts.query))
params.update({
'site':
frappe.local.site,
'email':
frappe.session.user,
'full_name':
get_fullname(),
'country':
frappe.db.get_value("System Settings", "System Settings", 'country')
})
query = urllib.urlencode(params, doseq=True)
url = urlparse.urlunsplit(
(parts.scheme, parts.netloc, parts.path, query, parts.fragment))
return url
def validate_leave_approver(employee, leave_approver, docstatus):
e = frappe.get_doc("Employee", employee)
leave_approvers = [l.leave_approver for l in e.get("leave_approvers")]
if len(leave_approvers) and leave_approver not in leave_approvers:
return "Leave approver must be one of {0}".format(
comma_or(leave_approvers))
elif leave_approver and not frappe.db.sql(
"""select name from `tabHas Role`
where parent=%s and role='Leave Approver'""", leave_approver):
return "{0} ({1}) must have role 'Leave Approver'".format(
get_fullname(leave_approver), leave_approver)
elif docstatus == 1 and len(
leave_approvers) and leave_approver != frappe.session.user:
return "Only the selected Leave Approver can submit this Leave Application"
return ""
def append_task_report(taskname, template_name, state=None, doc=None):
doc = doc or frappe.get_doc("Task", taskname)
project = doc.get("project")
task = doc.get("name")
user_allocated = frappe.get_value("ToDo", {
"reference_type": "Task",
"reference_name": doc.get("name")
}, "owner") or doc.get("owner")
implementer = get_fullname(user_allocated)
starts = doc.get("exp_start_date") or "unspecified"
ends = doc.get("exp_end_date") or "unspecified"
completed = [
x.get("task") for x in doc.get("depends_on")
if x.get("status") == "Completed"
]
all_tasks = [x.get("task") for x in doc.get("depends_on")]
#frappe.throw(str(len(completed)))
#frappe.throw(str(len(all_tasks)))
percent = len(completed) or 0.0 * 100 / len(all_tasks) or 0.0
period = f"{starts} to {ends}"
percent_progress = int(doc.get("progress"))
progress = f"{percent_progress} %"
priority = doc.get("priority")
status = doc.get("status")
activities = "<p>--</p>"
if doc.get("depends_on"):
activities = "<table style='width:100%;border:1px;padding: 0;margin: 0;border-collapse: collapse;border-spacing:0;'><tr><td>ID</td><td>Subject</td><td>Status</td><td>Remarks</td></tr>"
for d in doc.get("depends_on"):
t_name = d.get("task")
subj = d.get("subject")
stat = d.get("status") or ""
remarks = d.get("remarks") or "-"
activities += f"<tr><td>{t_name}</td><td>{subj}</td><td>{stat}</td><td><b>Remarks:</b> {remarks}</td></tr>"
activities += "</table>"
template = frappe.get_doc("Document Template", template_name)
text = template.get("part_a")
text2 = eval(f"f'{text}'")
if (state):
doc.set("description", text2)
return text2
def get_context(self, context):
# this is for double precaution. usually it wont reach this code if not published
if not cint(self.published):
raise Exception("This blog has not been published yet!")
# temp fields
context.full_name = get_fullname(self.owner)
context.updated = global_date_format(self.published_on)
if self.blogger:
context.blogger_info = frappe.get_doc("Blogger",
self.blogger).as_dict()
context.author = self.blogger
context.content = get_html_content_based_on_type(
self, 'content', self.content_type)
context.description = self.blog_intro or strip_html_tags(
context.content[:140])
context.metatags = {
"name": self.title,
"description": context.description,
}
image = find_first_image(context.content)
if image:
context.metatags["image"] = image
self.load_comments(context)
context.category = frappe.db.get_value("Blog Category",
context.doc.blog_category,
["title", "route"],
as_dict=1)
context.parents = [{
"name": _("Home"),
"route": "/"
}, {
"name": "Blog",
"route": "/blog"
}, {
"label": context.category.title,
"route": context.category.route
}]
def post(txt, contact, parenttype=None, notify=False, subject=None):
import frappe
"""post message"""
d = frappe.new_doc('Comment')
d.parenttype = parenttype
d.comment = txt
d.comment_docname = contact
d.comment_doctype = 'Message'
d.comment_by_fullname = get_fullname(frappe.session.user)
d.insert(ignore_permissions=True)
delete_notification_count_for("Messages")
if notify and cint(notify):
if contact==frappe.session.user:
_notify([user.name for user in get_enabled_system_users()], txt)
else:
_notify(contact, txt, subject)
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if (not self.get("party_name")) and self.contact_email:
# check if customer is already created agains the self.contact_email
dynamic_link, contact = DocType("Dynamic Link"), DocType("Contact")
customer = (frappe.qb.from_(dynamic_link).join(contact).on(
(contact.name == dynamic_link.parent)
& (dynamic_link.link_doctype == "Customer")
& (contact.email_id == self.contact_email)).select(
dynamic_link.link_name).distinct().run(as_dict=True))
if customer and customer[0].link_name:
self.party_name = customer[0].link_name
self.opportunity_from = "Customer"
return
lead_name = frappe.db.get_value("Lead",
{"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
if not sender_name and ("@" in self.contact_email):
email_name = self.contact_email.split("@")[0]
email_split = email_name.split(".")
sender_name = ""
for s in email_split:
sender_name += s.capitalize() + " "
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name or "Unknown"
})
lead.flags.ignore_email_validation = True
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.opportunity_from = "Lead"
self.party_name = lead_name
def _get_party(user):
customer = frappe.db.get_value("Contact", {"email_id": user}, "customer")
if customer:
return frappe.get_doc("Customer", customer)
lead = frappe.db.get_value("Lead", {"email_id": user})
if lead:
return frappe.get_doc("Lead", lead)
# create a lead
lead = frappe.new_doc("Lead")
lead.update({
"email_id": user,
"lead_name": get_fullname(user),
"territory": guess_territory()
})
lead.insert(ignore_permissions=True)
return lead
def log_invalid_item(item):
frappe.db.sql(
"""delete from `tabCommunication`
where
reference_doctype=%s and reference_name=%s
and communication_type='Comment'
and comment_type='Cancelled'""", ("Item", item.name))
frappe.get_doc({
"doctype": "Communication",
"communication_type": "Comment",
"comment_type": "Cancelled",
"reference_doctype": "Item",
"reference_name": item.name,
"subject": item.item_name,
"full_name": get_fullname(item.owner),
"reference_owner": item.owner,
# "link_doctype": "Item",
# "link_name": item.name
}).insert(ignore_permissions=True)
def get_alert_dict(doc):
alert_dict = frappe._dict()
owner_name = get_fullname(doc.owner)
if doc.reference_doctype:
doc_link = get_link_to_form(doc.reference_doctype, doc.reference_name)
points = doc.points
bold_points = frappe.bold(doc.points)
if doc.type == "Auto":
if points == 1:
message = _("You gained {0} point")
else:
message = _("You gained {0} points")
alert_dict.message = message.format(bold_points)
alert_dict.indicator = "green"
elif doc.type == "Appreciation":
if points == 1:
message = _("{0} appreciated your work on {1} with {2} point")
else:
message = _("{0} appreciated your work on {1} with {2} points")
alert_dict.message = message.format(owner_name, doc_link, bold_points)
alert_dict.indicator = "green"
elif doc.type == "Criticism":
if points == 1:
message = _("{0} criticized your work on {1} with {2} point")
else:
message = _("{0} criticized your work on {1} with {2} points")
alert_dict.message = message.format(owner_name, doc_link, bold_points)
alert_dict.indicator = "red"
elif doc.type == "Revert":
if points == 1:
message = _("{0} reverted your point on {1}")
else:
message = _("{0} reverted your points on {1}")
alert_dict.message = message.format(
owner_name,
doc_link,
)
alert_dict.indicator = "red"
return alert_dict
def get_alert_dict(doc):
alert_dict = frappe._dict()
owner_name = get_fullname(doc.owner)
if doc.reference_doctype:
doc_link = get_link_to_form(doc.reference_doctype, doc.reference_name)
points = doc.points
bold_points = frappe.bold(doc.points)
if doc.type == 'Auto':
if points == 1:
message = _('You gained {0} point')
else:
message = _('You gained {0} points')
alert_dict.message = message.format(bold_points)
alert_dict.indicator = 'green'
elif doc.type == 'Appreciation':
if points == 1:
message = _('{0} appreciated your work on {1} with {2} point')
else:
message = _('{0} appreciated your work on {1} with {2} points')
alert_dict.message = message.format(owner_name, doc_link, bold_points)
alert_dict.indicator = 'green'
elif doc.type == 'Criticism':
if points == 1:
message = _('{0} criticized your work on {1} with {2} point')
else:
message = _('{0} criticized your work on {1} with {2} points')
alert_dict.message = message.format(owner_name, doc_link, bold_points)
alert_dict.indicator = 'red'
elif doc.type == 'Revert':
if points == 1:
message = _('{0} reverted your point on {1}')
else:
message = _('{0} reverted your points on {1}')
alert_dict.message = message.format(
owner_name,
doc_link,
)
alert_dict.indicator = 'red'
return alert_dict
def info(_w_appid, _w_conf_name, _w_access_key, _w_signature):
valid_auth_code(_w_access_key)
_w_conf_name = _w_conf_name or frappe.get_request_header("x-weboffice-file-id")
data = get_post_json_data()
ids = data.get('ids')
if ids:
users = []
for id in ids:
users.append({
"id": id,
"name": get_fullname(id),
"avatar_url": "http://cloud.thingsroot.com/user?id=" + id
})
frappe.response.update({
"users": users
})
else:
throw("missing_ids")
def validate(self):
if not self.parent_post and not self.title:
frappe.throw(_("Title is required"))
self.assigned_to = frappe.db.get_value(self.doctype, self.name, "assigned_to")
if self.is_task:
if not self.status:
self.status = "Open"
if self.assigned_to:
if not self.assigned_to_fullname:
self.assigned_to_fullname = get_fullname(self.assigned_to)
else:
self.assigned_to_fullname = None
else:
self.assigned_to = self.assigned_to_fullname = self.status = None
if self.is_event:
if not self.event_datetime:
frappe.throw(_("Please specify Event date and time"))
else:
self.event_datetime = None
def notify_assignment(shared_by, doctype, doc_name, everyone):
if not (shared_by and doctype and doc_name) or everyone: return
from frappe.utils import get_fullname
title = get_title(doctype, doc_name)
reference_user = get_fullname(frappe.session.user)
notification_message = _('{0} shared a document {1} {2} with you').format(
frappe.bold(reference_user), frappe.bold(doctype), get_title_html(title))
notification_doc = {
'type': 'Share',
'document_type': doctype,
'subject': notification_message,
'document_name': doc_name,
'from_user': frappe.session.user
}
enqueue_create_notification(shared_by, notification_doc)
