def process_message(self, mail):
		if mail.from_email == self.settings.email_id:
			return
			
		name = webnotes.conn.get_value("Job Applicant", {"email_id": mail.from_email}, 
			"name")
		if name:
			applicant = webnotes.model_wrapper("Job Applicant", name)
			if applicant.doc.status!="Rejected":
				applicant.doc.status = "Open"
			applicant.doc.save()
		else:
			name = (mail.from_real_name and (mail.from_real_name + " - ") or "") \
				+ mail.from_email
			applicant = webnotes.model_wrapper({
				"doctype":"Job Applicant",
				"applicant_name": name,
				"email_id": mail.from_email,
				"status": "Open"
			})
			applicant.insert()
		
		mail.save_attachments_in_doc(applicant.doc)
				
		make(content=mail.content, sender=mail.from_email, 
			doctype="Job Applicant", name=applicant.doc.name, set_lead=False)

	def process_message(self, mail):
		if mail.from_email == self.email_settings.fields.get('support_email'):
			return
		thread_id = mail.get_thread_id()
		ticket = None

		if thread_id and webnotes.conn.exists("Support Ticket", thread_id):
			ticket = webnotes.model_wrapper("Support Ticket", thread_id)
			ticket.doc.status = 'Open'
			ticket.doc.save()
				
		else:
			ticket = webnotes.model_wrapper([{
				"doctype":"Support Ticket",
				"description": mail.content,
				"subject": mail.mail["Subject"],
				"raised_by": mail.from_email,
				"content_type": mail.content_type,
				"status": "Open"
			}])
			ticket.insert()

			if cint(self.email_settings.send_autoreply):
				if "mailer-daemon" not in mail.from_email.lower():
					self.send_auto_reply(ticket.doc)

		mail.save_attachments_in_doc(ticket.doc)
				
		make(content=mail.content, sender=mail.from_email, subject = ticket.doc.subject,
			doctype="Support Ticket", name=ticket.doc.name, 
			lead = ticket.doc.lead, contact=ticket.doc.contact, date=mail.date)

	def on_update(self):
		"""clear web cache"""
		from website.utils import clear_cache
		clear_cache()
		
		if self.doc.default_product_category:
			webnotes.model_wrapper("Item Group", 
				self.doc.default_product_category).save()

def move_remarks_to_comments():
	from webnotes.utils import get_fullname
	result = webnotes.conn.sql("""select name, remark, modified_by from `tabStock Reconciliation`
		where ifnull(remark, '')!=''""")
	fullname_map = {}
	for reco, remark, modified_by in result:
		webnotes.model_wrapper([{
			"doctype": "Comment",
			"comment": remark,
			"comment_by": modified_by,
			"comment_by_fullname": fullname_map.setdefault(modified_by, get_fullname(modified_by)),
			"comment_doctype": "Stock Reconciliation",
			"comment_docname": reco
		}]).insert()

	def test_gl_entries(self):
		wrapper = webnotes.model_wrapper(self.get_test_doclist())
		
		# circumvent the disabled calculation call
		obj = webnotes.get_obj(doc=wrapper.doc, doclist=wrapper.doclist)
		obj.calculate_taxes_and_totals()
		wrapper.set_doclist(obj.doclist)
		
		wrapper.insert()
		wrapper.submit()
		wrapper.load_from_db()
		dl = wrapper.doclist
		
		expected_gl_entries = {
			"_Test Supplier - _TC": [0, 1512.30],
			"_Test Account Cost for Goods Sold - _TC": [1250, 0],
			"_Test Account Shipping Charges - _TC": [100, 0],
			"_Test Account Excise Duty - _TC": [140, 0],
			"_Test Account Education Cess - _TC": [2.8, 0],
			"_Test Account S&H Education Cess - _TC": [1.4, 0],
			"_Test Account CST - _TC": [29.88, 0],
			"_Test Account VAT - _TC": [156.25, 0],
			"_Test Account Discount - _TC": [0, 168.03],
		}
		gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry`
			where voucher_type = 'Purchase Invoice' and voucher_no = %s""", dl[0].name, as_dict=1)
		for d in gl_entries:
			self.assertEqual([d.debit, d.credit], expected_gl_entries.get(d.account))

	def test_get_recipients_lead(self):
		w = webnotes.model_wrapper(test_records[0])
		w.insert()
		self.assertTrue("[email protected]" in w.controller.get_recipients())
		webnotes.conn.sql("""delete from `tabBulk Email`""")
		w.controller.send_emails()
		self.assertTrue(webnotes.conn.get_value("Bulk Email", {"recipient": "[email protected]"}))

def add_node():
    # from webnotes.model.doc import Document
    ctype = webnotes.form_dict.get("ctype")
    parent_field = "parent_" + ctype.lower().replace(" ", "_")
    name_field = ctype.lower().replace(" ", "_") + "_name"

    doclist = [
        {
            "doctype": ctype,
            "__islocal": 1,
            name_field: webnotes.form_dict["name_field"],
            parent_field: webnotes.form_dict["parent"],
            "is_group": webnotes.form_dict["is_group"],
        }
    ]
    webnotes.model_wrapper(doclist).save()

def execute():
	for name in webnotes.conn.sql("""select name from `tabHoliday List`"""):
		holiday_list_wrapper = webnotes.model_wrapper("Holiday List", name[0])
		
		desc_count = _count([d.description for d in 
			holiday_list_wrapper.doclist.get({"doctype": "Holiday"})])
			
		holiday_list_obj = webnotes.get_obj(doc=holiday_list_wrapper.doc,
			doclist=holiday_list_wrapper.doclist)
			
		save = False
		
		for desc in desc_count.keys():
			if desc in ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
					"Friday", "Saturday"] and desc_count[desc] > 50:
				holiday_list_obj.doclist = holiday_list_obj.doclist.get(
					{"description": ["!=", desc]})
				
				webnotes.conn.sql("""delete from `tabHoliday`
					where parent=%s and parenttype='Holiday List' 
					and `description`=%s""", (holiday_list_obj.doc.name, desc))
				holiday_list_obj.doc.weekly_off = desc
				holiday_list_obj.get_weekly_off_dates()
				save = True
		
		if save:
			holiday_list_wrapper.set_doclist(holiday_list_obj.doclist)
			holiday_list_wrapper.save()

	def add_cc(self,arg):
		cc = webnotes.model_wrapper(eval(arg))
		cc.doc.doctype = "Cost Center"
		cc.doc.old_parent = ""
		cc.insert()

		return cc.doc.name

	def process_message(self, mail):
		name = self.get_existing_application(mail.from_email)
		if name:
			applicant = webnotes.model_wrapper("Job Applicant", name)
		else:
			applicant = webnotes.model_wrapper({
				"doctype":"Job Applicant",
				"applicant_name": mail.from_real_name or mail.from_email,
				"email_id": mail.from_email
			})
			applicant.insert()
		
		mail.save_attachments_in_doc(applicant.doc)
				
		make(content=mail.content, sender=mail.from_email, 
			doctype="Job Applicant", name=applicant.doc.name, set_lead=False)

	def set_status(doctype, name):
		w = webnotes.model_wrapper(doctype, name)
		w.ignore_permissions = True
		w.doc.status = is_system_user and "Replied" or status
		w.doc.save()
		if mail:
			mail.save_attachments_in_doc(w.doc)

def add_sales_communication(subject, content, sender, real_name, mail=None, 
	status="Open", date=None):
	def set_status(doctype, name):
		w = webnotes.model_wrapper(doctype, name)
		w.ignore_permissions = True
		w.doc.status = is_system_user and "Replied" or status
		w.doc.save()
		if mail:
			mail.save_attachments_in_doc(w.doc)

	lead_name = webnotes.conn.get_value("Lead", {"email_id": sender})
	contact_name = webnotes.conn.get_value("Contact", {"email_id": sender})
	is_system_user = webnotes.conn.get_value("Profile", sender)

	if not (lead_name or contact_name):
		# none, create a new Lead
		lead = webnotes.model_wrapper({
			"doctype":"Lead",
			"lead_name": real_name or sender,
			"email_id": sender,
			"status": status,
			"source": "Email"
		})
		lead.ignore_permissions = True
		lead.insert()
		lead_name = lead.doc.name

	make(content=content, sender=sender, subject=subject,
		lead=lead_name, contact=contact_name, date=date)
	
	if contact_name:
		set_status("Contact", contact_name)
	elif lead_name:
		set_status("Lead", lead_name)

def save_report():
	"""save report"""
	from webnotes.model.doc import Document
	
	data = webnotes.form_dict
	if webnotes.conn.exists('Report', data['name'].title()):
		d = Document('Report', data['name'].title())
	else:
		d = Document('Report')
		d.name = data['name']
		d.ref_doctype = data['doctype']
		
	d.json = data['json']
	webnotes.model_wrapper([d]).save()
	webnotes.msgprint("%s saved." % d.name)
	return d.name

def manage_recurring_invoices():
	""" 
		Create recurring invoices on specific date by copying the original one
		and notify the concerned people
	"""
	recurring_invoices = webnotes.conn.sql("""select name, recurring_id
		from `tabSales Invoice` where ifnull(convert_into_recurring_invoice, 0)=1
		and docstatus=1 and next_date=%s
		and next_date <= ifnull(end_date, '2199-12-31')""", nowdate())
	
	exception_list = []
	for ref_invoice, recurring_id in recurring_invoices:
		if not webnotes.conn.sql("""select name from `tabSales Invoice`
				where posting_date=%s and recurring_id=%s and docstatus=1""",
				(nowdate(), recurring_id)):
			try:
				ref_wrapper = webnotes.model_wrapper('Sales Invoice', ref_invoice)
				new_invoice_wrapper = make_new_invoice(ref_wrapper)
				send_notification(new_invoice_wrapper)
				webnotes.conn.commit()
			except Exception, e:
				webnotes.conn.rollback()

				webnotes.conn.begin()
				webnotes.conn.sql("update `tabSales Invoice` set \
					convert_into_recurring_invoice = 0 where name = %s", ref_invoice)
				notify_errors(ref_invoice, ref_wrapper.doc.owner)
				webnotes.conn.commit()

				exception_list.append(webnotes.getTraceback())
			finally:

def get_slideshow(obj):
	slideshow = webnotes.model_wrapper("Website Slideshow", obj.doc.slideshow)
	obj.slides = slideshow.doclist.get({"doctype":"Website Slideshow Item"})
	obj.doc.slideshow_header = slideshow.doc.header or ""
	for s in obj.slides:
		if s.image and not s.image.lower().startswith("http"):
			s.image = "files/" + s.image

	def test_purchase_invoice_calculation(self):
		test_doclist = [] + purchase_invoice_doclist
		for doc in test_doclist:
			if doc["doctype"] == "Purchase Taxes and Charges":
				del doc["tax_amount"]
				
		wrapper = webnotes.model_wrapper(test_doclist).insert()
		wrapper.load_from_db()
		
		# tax amounts
		expected_values = [
			["Shipping Charges - %s" % abbr, 100, 1350],
			["Customs Duty - %s" % abbr, 125, 1350],
			["Excise Duty - %s" % abbr, 140, 1490],
			["Education Cess - %s" % abbr, 2.8, 1492.8],
			["S&H Education Cess - %s" % abbr, 1.4, 1494.2],
			["CST - %s" % abbr, 29.88, 1524.08],
			["VAT - Test - %s" % abbr, 156.25, 1680.33],
			["Discount - %s" % abbr, 168.03, 1512.30],
		]
		
		for i, tax in enumerate(wrapper.doclist.get({"parentfield": "purchase_tax_details"})):
			self.assertEqual(tax.account_head, expected_values[i][0])
			self.assertEqual(tax.tax_amount, expected_values[i][1])
			self.assertEqual(tax.total, expected_values[i][2])

		expected_values = [
			["Home Desktop 100", 90],
			["Home Desktop 200", 135]
		]
		for i, item in enumerate(wrapper.doclist.get({"parentfield": "entries"})):
			self.assertEqual(item.item_code, expected_values[i][0])
			self.assertEqual(item.item_tax_amount, expected_values[i][1])

def add_role(profile, role):
	profile_wrapper = webnotes.model_wrapper("Profile", profile)
	profile_wrapper.doclist.append({
		"doctype": "UserRole",
		"parentfield": "user_roles",
		"role": role
	})
	profile_wrapper.save()

	def onload(self):
		"""load address"""
		if self.doc.query_options:
			self.doc.query_options = filter(None, self.doc.query_options.replace(",", "\n").split())
		else:
			self.doc.query_options = ["Sales", "Support", "General"]
		if self.doc.address:
			self.address = webnotes.model_wrapper("Address", self.doc.address).doc

	def add_ac(self,arg):
		ac = webnotes.model_wrapper(eval(arg))
		ac.doc.doctype = "Account"
		ac.doc.old_parent = ""
		ac.doc.freeze_account = "No"
		ac.insert()

		return ac.doc.name

def submit(doclist):
	if isinstance(doclist, basestring):
		doclist = json.loads(doclist)

	doclistobj = webnotes.model_wrapper(doclist)
	doclistobj.submit()
	
	return [d.fields for d in doclist]