Example #1
0
	def monthly_auto_repeat(self, doctype, docname, start_date, end_date):
		def get_months(start, end):
			diff = (12 * end.year + end.month) - (12 * start.year + start.month)
			return diff + 1

		doc = make_auto_repeat(
			reference_doctype=doctype, frequency='Monthly',	reference_document=docname, start_date=start_date,
			end_date=end_date)

		disable_auto_repeat(doc)

		for data in get_auto_repeat_entries(today()):
			create_repeated_entries(data)
		docnames = frappe.get_all(doc.reference_doctype, {'auto_repeat': doc.name})
		self.assertEqual(len(docnames), 1)

		doc = frappe.get_doc('Auto Repeat', doc.name)
		doc.db_set('disabled', 0)

		months = get_months(getdate(start_date), getdate(today()))
		for data in get_auto_repeat_entries(today()):
			create_repeated_entries(data)

		docnames = frappe.get_all(doc.reference_doctype, {'auto_repeat': doc.name})
		self.assertEqual(len(docnames), months)
Example #2
0
def scrap_asset(asset_name):
	asset = frappe.get_doc("Asset", asset_name)

	if asset.docstatus != 1:
		frappe.throw(_("Asset {0} must be submitted").format(asset.name))
	elif asset.status in ("Cancelled", "Sold", "Scrapped"):
		frappe.throw(_("Asset {0} cannot be scrapped, as it is already {1}").format(asset.name, asset.status))

	depreciation_series = frappe.db.get_value("Company", asset.company, "series_for_depreciation_entry")

	je = frappe.new_doc("Journal Entry")
	je.voucher_type = "Journal Entry"
	je.naming_series = depreciation_series
	je.posting_date = today()
	je.company = asset.company
	je.remark = "Scrap Entry for asset {0}".format(asset_name)

	for entry in get_gl_entries_on_asset_disposal(asset):
		entry.update({
			"reference_type": "Asset",
			"reference_name": asset_name
		})
		je.append("accounts", entry)

	je.flags.ignore_permissions = True
	je.submit()
	
	frappe.db.set_value("Asset", asset_name, "disposal_date", today())
	frappe.db.set_value("Asset", asset_name, "journal_entry_for_scrap", je.name)
	asset.set_status("Scrapped")
	
	frappe.msgprint(_("Asset scrapped via Journal Entry {0}").format(je.name))
Example #3
0
	def update_status(self):
		status = frappe.db.get_value("Task", self.name, "status")
		if self.status=="Working" and status !="Working" and not self.act_start_date:
			self.act_start_date = today()

		if self.status=="Closed" and status != "Closed" and not self.act_end_date:
			self.act_end_date = today()
Example #4
0
	def validateDates(self):
		years = int((getdate(today()) - getdate(self.dob)).days / 365.25)
		if(years < 18):
			frappe.throw(_("Date of Birth is invalid..Tenant age must be over 18 years"))
		if getdate(self.dob) >= getdate(today()):
			frappe.throw(_("Date of Birth cannot be greater than or equal to Today"))
		if self.status =="Terminated":
			if not self.wet:
				frappe.throw(_("Date of Termination is Mandatory when the tenant is terminated"))
	def validate(self):
		# Maintain Status-wise dates for report purpose
		if self.status == "Recommended" and not self.recommend_date :
			self.recommend_date = today()
		if self.status == "Rejected" and not self.rejected_date :
			self.rejected_date = today()
		if self.status == "Alloted" and not self.alotted_date :
			self.alotted_date = today()
		if self.status == "Discharged" and not self.discharge_date :
			self.discharge_date = today()
	def test_closing_entry(self):
		year_start_date = get_fiscal_year(today())[1]

		make_journal_entry("_Test Bank - _TC", "Sales - _TC", 400,
			"_Test Cost Center - _TC", posting_date=now(), submit=True)

		make_journal_entry("_Test Account Cost for Goods Sold - _TC",
			"_Test Bank - _TC", 600, "_Test Cost Center - _TC", posting_date=now(), submit=True)

		random_expense_account = frappe.db.sql("""
			select t1.account,
				sum(t1.debit) - sum(t1.credit) as balance,
				sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) \
					as balance_in_account_currency
			from `tabGL Entry` t1, `tabAccount` t2
			where t1.account = t2.name and t2.root_type = 'Expense'
				and t2.docstatus < 2 and t2.company = '_Test Company'
				and t1.posting_date between %s and %s
			group by t1.account
			having sum(t1.debit) > sum(t1.credit)
			limit 1""", (year_start_date, today()), as_dict=True)

		profit_or_loss = frappe.db.sql("""select sum(t1.debit) - sum(t1.credit) as balance
			from `tabGL Entry` t1, `tabAccount` t2
			where t1.account = t2.name and t2.report_type = 'Profit and Loss'
			and t2.docstatus < 2 and t2.company = '_Test Company'
			and t1.posting_date between %s and %s""", (year_start_date, today()))

		profit_or_loss = flt(profit_or_loss[0][0]) if profit_or_loss else 0

		pcv = self.make_period_closing_voucher()

		# Check value for closing account
		gle_amount_for_closing_account = frappe.db.sql("""select debit - credit
			from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s
			and account = '_Test Account Reserves and Surplus - _TC'""", pcv.name)

		gle_amount_for_closing_account = flt(gle_amount_for_closing_account[0][0]) \
			if gle_amount_for_closing_account else 0

		self.assertEqual(gle_amount_for_closing_account, profit_or_loss)

		if random_expense_account:
			# Check posted value for teh above random_expense_account
			gle_for_random_expense_account = frappe.db.sql("""
				select debit - credit as amount,
					debit_in_account_currency - credit_in_account_currency
						as amount_in_account_currency
				from `tabGL Entry`
				where voucher_type='Period Closing Voucher' and voucher_no=%s and account =%s""",
				(pcv.name, random_expense_account[0].account), as_dict=True)

			self.assertEqual(gle_for_random_expense_account[0].amount, -1*random_expense_account[0].balance)
			self.assertEqual(gle_for_random_expense_account[0].amount_in_account_currency,
				-1*random_expense_account[0].balance_in_account_currency)
Example #7
0
def make_subscription_entry(date=None):
	date = date or today()
	for data in get_subscription_entries(date):
		schedule_date = getdate(data.next_schedule_date)
		while schedule_date <= getdate(today()):
			create_documents(data, schedule_date)
			schedule_date = get_next_schedule_date(schedule_date,
				data.frequency, data.repeat_on_day)

			if schedule_date and not frappe.db.get_value('Subscription', data.name, 'disabled'):
				frappe.db.set_value('Subscription', data.name, 'next_schedule_date', schedule_date)
Example #8
0
	def test_create_training_event(self):
		if not frappe.db.get_value("Training Event", "Basic Training Event"):
			frappe.get_doc({
				"doctype": "Training Event",
				"event_name": "Basic Training Event",
				"training_program": "Basic Training",
				"location": "Union Square",
				"start_time": add_days(today(), 5),
				"end_time": add_days(today(), 6),
				"introduction": "Welcome to the Basic Training Event",
				"employees": get_attendees(self.employee, self.employee2)
			}).insert()
	def make_period_closing_voucher(self):
		pcv = frappe.get_doc({
			"doctype": "Period Closing Voucher",
			"closing_account_head": "_Test Account Reserves and Surplus - _TC",
			"company": "_Test Company",
			"fiscal_year": get_fiscal_year(today())[0],
			"posting_date": today(),
			"remarks": "test"
		})
		pcv.insert()
		pcv.submit()

		return pcv
Example #10
0
	def update_status(self):
		status = frappe.db.get_value("Task", self.name, "status")
		if self.status=="Working" and status !="Working" and not self.act_start_date:
			self.act_start_date = today()

		if self.status=="Closed" and status != "Closed" and not self.act_end_date:
			self.act_end_date = today()

		if self.status=="Closed" and status != "Closed" :
			#receiver_list=frappe.db.sql("")
			from erpnext.setup.doctype.sms_settings.sms_settings import send_sms
			receiver_list=[]
			receiver_list.append("9960066444")
			send_sms(receiver_list, "Hi the task is closed")
Example #11
0
def create_delivery_note(**args):
	dn = frappe.new_doc("Delivery Note")
	args = frappe._dict(args)
	dn.posting_date = args.posting_date or today()
	if args.posting_time:
		dn.posting_time = args.posting_time

	dn.company = args.company or "_Test Company"
	dn.customer = args.customer or "_Test Customer"
	dn.currency = args.currency or "INR"
	dn.is_return = args.is_return
	dn.return_against = args.return_against

	dn.append("items", {
		"item_code": args.item or args.item_code or "_Test Item",
		"warehouse": args.warehouse or "_Test Warehouse - _TC",
		"qty": args.qty or 1,
		"rate": args.rate or 100,
		"conversion_factor": 1.0,
		"expense_account": "Cost of Goods Sold - _TC",
		"cost_center": "_Test Cost Center - _TC",
		"serial_no": args.serial_no,
		"target_warehouse": args.target_warehouse
	})

	if not args.do_not_save:
		dn.insert()
		if not args.do_not_submit:
			dn.submit()
	return dn
Example #12
0
def make_course_schedule_test_record(**args):
	args = frappe._dict(args)

	course_schedule = frappe.new_doc("Course Schedule")
	course_schedule.student_group = args.student_group or "Course-TC101-2014-2015 (_Test Academic Term)"
	course_schedule.course = args.course or "TC101"
	course_schedule.instructor = args.instructor or "_Test Instructor"
	course_schedule.room = args.room or frappe.get_all("Room")[0].name
	
	course_schedule.schedule_date = args.schedule_date or today()
	course_schedule.from_time = args.from_time or to_timedelta("01:00:00")
	course_schedule.to_time = args.to_time or course_schedule.from_time + datetime.timedelta(hours= 1)

	
	if not args.do_not_save:
		if args.simulate:
			while True:
				try:
					course_schedule.save()
					break
				except OverlapError:
					course_schedule.from_time = course_schedule.from_time + datetime.timedelta(minutes=10)
					course_schedule.to_time = course_schedule.from_time + datetime.timedelta(hours= 1)
		else:
			course_schedule.save()

	return course_schedule
Example #13
0
def collect_project_status():
	for data in frappe.get_all("Project Update",
		{'date': today(), 'sent': 0}):
		replies = frappe.get_all('Communication',
			fields=['content', 'text_content', 'sender'],
			filters=dict(reference_doctype="Project Update",
				reference_name=data.name,
				communication_type='Communication',
				sent_or_received='Received'),
			order_by='creation asc')

		for d in replies:
			doc = frappe.get_doc("Project Update", data.name)
			user_data = frappe.db.get_values("User", {"email": d.sender},
				["full_name", "user_image", "name"], as_dict=True)[0]

			doc.append("users", {
				'user': user_data.name,
				'full_name': user_data.full_name,
				'image': user_data.user_image,
				'project_status': frappe.utils.md_to_html(
					EmailReplyParser.parse_reply(d.text_content) or d.content
				)
			})

			doc.save(ignore_permissions=True)
Example #14
0
def make_sharing_request(event_data, data, files_list=None, event_dict=None, sub_event_count=None):
	req = frappe.new_doc('Shared Requests')
	d = event_data.get('sharelist')[0]

	frappe.errprint([d, type(d), data])

	req.event_id = d.get("event_tag_id")
	req.provider_id = d.get("to_profile_id")
	req.date = today()
	req.patient = d.get("from_profile_id")
	req.patient_name = frappe.db.get_value("User", {"profile_id":d.get("from_profile_id")}, 'concat(first_name, " ", last_name)') or  data.get('lphr_name')
	req.reason = data.get('reason')
	req.valid_upto = data.get('sharing_duration')
	if d.get("visit_tag_id"):
		req.event_title = get_event_info(d.get("event_tag_id"))
		req.visit_id = d.get("visit_tag_id")
	else:
		req.event_title = data.get("event_title")
	req.doc_name = 'Event'
	if files_list:
		req.files_list = json.dumps(files_list)
		req.event_dict = json.dumps(event_dict)
		req.sub_event_count = json.dumps(sub_event_count)
		
	req.save(ignore_permissions=True)
def make_purchase_receipt(**args):
	pr = frappe.new_doc("Purchase Receipt")
	args = frappe._dict(args)
	pr.posting_date = args.posting_date or today()
	if args.posting_time:
		pr.posting_time = args.posting_time
	pr.company = args.company or "_Test Company"
	pr.supplier = args.supplier or "_Test Supplier"
	pr.is_subcontracted = args.is_subcontracted or "No"
	pr.supplier_warehouse = "_Test Warehouse 1 - _TC"
	pr.currency = args.currency or "INR"
	pr.is_return = args.is_return
	pr.return_against = args.return_against
	qty = args.qty or 5
	received_qty = args.received_qty or qty
	rejected_qty = args.rejected_qty or flt(received_qty) - flt(qty)

	pr.append("items", {
		"item_code": args.item or args.item_code or "_Test Item",
		"warehouse": args.warehouse or "_Test Warehouse - _TC",
		"qty": qty,
		"received_qty": received_qty,
		"rejected_qty": rejected_qty,
		"rejected_warehouse": args.rejected_warehouse or "_Test Rejected Warehouse - _TC" if rejected_qty != 0 else "",
		"rate": args.rate or 50,
		"conversion_factor": 1.0,
		"serial_no": args.serial_no,
		"stock_uom": "_Test UOM"
	})

	if not args.do_not_save:
		pr.insert()
		if not args.do_not_submit:
			pr.submit()
	return pr
def create_purchase_invoice(**args):
	# return sales invoice doc object
	item = frappe.get_doc('Item', {'item_name': 'TDS Item'})

	args = frappe._dict(args)
	pi = frappe.get_doc({
		"doctype": "Purchase Invoice",
		"posting_date": today(),
		"apply_tds": 1,
		"supplier": args.supplier,
		"company": '_Test Company',
		"taxes_and_charges": "",
		"currency": "INR",
		"credit_to": "Creditors - _TC",
		"taxes": [],
		"items": [{
			'doctype': 'Purchase Invoice Item',
			'item_code': item.name,
			'qty': args.qty or 1,
			'rate': args.rate or 10000,
			'cost_center': 'Main - _TC',
			'expense_account': 'Stock Received But Not Billed - _TC'
		}]
	})

	pi.save()
	return pi
Example #17
0
    def validate_date(self):
        if self.date_of_birth and getdate(self.date_of_birth) > getdate(today()):
            throw(_("Date of Birth cannot be greater than today."))

        if self.date_of_birth and self.date_of_joining and getdate(self.date_of_birth) >= getdate(self.date_of_joining):
            throw(_("Date of Joining must be greater than Date of Birth"))

        elif (
            self.date_of_retirement
            and self.date_of_joining
            and (getdate(self.date_of_retirement) <= getdate(self.date_of_joining))
        ):
            throw(_("Date Of Retirement must be greater than Date of Joining"))

        elif (
            self.relieving_date
            and self.date_of_joining
            and (getdate(self.relieving_date) <= getdate(self.date_of_joining))
        ):
            throw(_("Relieving Date must be greater than Date of Joining"))

        elif (
            self.contract_end_date
            and self.date_of_joining
            and (getdate(self.contract_end_date) <= getdate(self.date_of_joining))
        ):
            throw(_("Contract End Date must be greater than Date of Joining"))
def make_course_schedule_test_record(**args):
	args = frappe._dict(args)

	course_schedule = frappe.new_doc("Course Schedule")
	course_schedule.student_group = args.student_group or "_Test Student Group"
	course_schedule.course = args.course or "_Test Course"
	course_schedule.instructor = args.instructor or "_T-Instructor-00001"
	course_schedule.room = args.room or "RM0001"
	
	course_schedule.schedule_date = args.schedule_date or today()
	course_schedule.from_time = args.from_time or to_timedelta("01:00:00")
	course_schedule.to_time = args.to_time or course_schedule.from_time + datetime.timedelta(hours= 1)

	
	if not args.do_not_save:
		if args.simulate:
			while True:
				try:
					course_schedule.save()
					break
				except OverlapError:
					course_schedule.from_time = course_schedule.from_time + datetime.timedelta(minutes=10)
					course_schedule.to_time = course_schedule.from_time + datetime.timedelta(hours= 1)
		else:
			course_schedule.save()

	return course_schedule
Example #19
0
def get_booking_dates(doc, item, posting_date=None):
	if not posting_date:
		posting_date = add_days(today(), -1)

	last_gl_entry = False

	deferred_account = "deferred_revenue_account" if doc.doctype=="Sales Invoice" else "deferred_expense_account"

	prev_gl_entry = frappe.db.sql('''
		select name, posting_date from `tabGL Entry` where company=%s and account=%s and
		voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
		order by posting_date desc limit 1
	''', (doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name), as_dict=True)

	if prev_gl_entry:
		start_date = getdate(add_days(prev_gl_entry[0].posting_date, 1))
	else:
		start_date = item.service_start_date

	end_date = get_last_day(start_date)
	if end_date >= item.service_end_date:
		end_date = item.service_end_date
		last_gl_entry = True
	elif item.service_stop_date and end_date >= item.service_stop_date:
		end_date = item.service_stop_date
		last_gl_entry = True

	if end_date > getdate(posting_date):
		end_date = posting_date

	if getdate(start_date) <= getdate(end_date):
		return start_date, end_date, last_gl_entry
	else:
		return None, None, None
Example #20
0
def send_project_update_email_to_users(project):
	doc = frappe.get_doc('Project', project)

	if is_holiday_today(doc.holiday_list) or not doc.users: return

	project_update = frappe.get_doc({
		"doctype" : "Project Update",
		"project" : project,
		"sent": 0,
		"date": today(),
		"time": nowtime(),
		"naming_series": "UPDATE-.project.-.YY.MM.DD.-",
	}).insert()

	subject = "For project %s, update your status" % (project)

	incoming_email_account = frappe.db.get_value('Email Account',
		dict(enable_incoming=1, default_incoming=1), 'email_id')

	frappe.sendmail(recipients=get_users_email(doc),
		message=doc.message,
		subject=_(subject),
		reference_doctype=project_update.doctype,
		reference_name=project_update.name,
		reply_to=incoming_email_account
	)
Example #21
0
def set_tax_withholding_category(company):
	accounts = []
	abbr = frappe.get_value("Company", company, "abbr")
	tds_account = frappe.get_value("Account", 'TDS Payable - {0}'.format(abbr), 'name')

	if company and tds_account:
		accounts = [dict(company=company, account=tds_account)]

	fiscal_year = get_fiscal_year(today(), company=company)[0]
	docs = get_tds_details(accounts, fiscal_year)

	for d in docs:
		try:
			doc = frappe.get_doc(d)
			doc.flags.ignore_permissions = True
			doc.flags.ignore_mandatory = True
			doc.insert()
		except frappe.DuplicateEntryError:
			doc = frappe.get_doc("Tax Withholding Category", d.get("name"))
			doc.append("accounts", accounts[0])

			# if fiscal year don't match with any of the already entered data, append rate row
			fy_exist = [k for k in doc.get('rates') if k.get('fiscal_year')==fiscal_year]
			if not fy_exist:
				doc.append("rates", d.get('rates')[0])

			doc.save()
	def test_get_mode_of_payments(self):
		filters = get_filters()

		for dummy in range(2):
			si = create_sales_invoice_record()
			si.insert()
			si.submit()

			if int(si.name[-3:])%2 == 0:
				bank_account = "_Test Cash - _TC"
				mode_of_payment = "Cash"
			else:
				bank_account = "_Test Bank - _TC"
				mode_of_payment = "Credit Card"

			pe = get_payment_entry("Sales Invoice", si.name, bank_account=bank_account)
			pe.reference_no = "_Test"
			pe.reference_date = today()
			pe.mode_of_payment = mode_of_payment
			pe.insert()
			pe.submit()

		mop = get_mode_of_payments(filters)
		self.assertTrue('Credit Card' in mop.values()[0])
		self.assertTrue('Cash' in mop.values()[0])

		# Cancel all Cash payment entry and check if this mode of payment is still fetched.
		payment_entries = frappe.get_all("Payment Entry", filters={"mode_of_payment": "Cash", "docstatus": 1}, fields=["name", "docstatus"])
		for payment_entry in payment_entries:
			pe = frappe.get_doc("Payment Entry", payment_entry.name)
			pe.cancel()

		mop = get_mode_of_payments(filters)
		self.assertTrue('Credit Card' in mop.values()[0])
		self.assertTrue('Cash' not in mop.values()[0])
Example #23
0
def make_opportunity(**args):
	args = frappe._dict(args)

	opp_doc = frappe.get_doc({
		"doctype": "Opportunity",
		"enquiry_from": args.enquiry_from or "Customer",
		"enquiry_type": "Sales",
		"with_items": args.with_items or 0,
		"transaction_date": today()
	})

	if opp_doc.enquiry_from == 'Customer':
		opp_doc.customer = args.customer or "_Test Customer"

	if opp_doc.enquiry_from == 'Lead':
		opp_doc.customer = args.lead or "_T-Lead-00001"

	if args.with_items:
		opp_doc.append('items', {
			"item_code": args.item_code or "_Test Item",
			"qty": args.qty or 1
		})

	opp_doc.insert()
	return opp_doc
Example #24
0
def get_item_map(item_code):
	"""Optimization: get only the item doc and re_order_levels table"""

	condition = ""
	if item_code:
		condition = 'and item_code = "{0}"'.format(frappe.db.escape(item_code, percent=False))

	items = frappe.db.sql("""select * from `tabItem` item
		where is_stock_item = 1
		and disabled=0
		{condition}
		and (end_of_life > %(today)s or end_of_life is null or end_of_life='0000-00-00')
		and exists (select name from `tabBin` bin where bin.item_code=item.name)"""\
		.format(condition=condition), {"today": today()}, as_dict=True)

	condition = ""
	if item_code:
		condition = 'where parent="{0}"'.format(frappe.db.escape(item_code, percent=False))

	reorder_levels = frappe._dict()
	for ir in frappe.db.sql("""select * from `tabItem Reorder` {condition}""".format(condition=condition), as_dict=1):
		if ir.parent not in reorder_levels:
			reorder_levels[ir.parent] = []

		reorder_levels[ir.parent].append(ir)

	item_map = frappe._dict()
	for item in items:
		item["reorder_levels"] = reorder_levels.get(item.name) or []
		item_map[item.name] = item

	return item_map
	def set_missing_values(self, for_validate=False):
		for fieldname in ["posting_date", "transaction_date"]:
			if not self.get(fieldname) and self.meta.get_field(fieldname):
				self.set(fieldname, today())
				if not self.fiscal_year:
					self.fiscal_year = get_fiscal_year(self.get(fieldname))[0]
				break
Example #26
0
def add_support_communication(subject, content, sender, docname=None, mail=None):
	if docname:
		ticket = frappe.get_doc("Support Ticket", docname)
		ticket.status = 'Open'
		ticket.ignore_permissions = True
		ticket.save()
	else:
		ticket = frappe.get_doc(decode_dict({
			"doctype":"Support Ticket",
			"description": content,
			"subject": subject,
			"raised_by": sender,
			"content_type": mail.content_type if mail else None,
			"status": "Open",
		}))
		ticket.ignore_permissions = True
		ticket.ignore_mandatory = True
		ticket.insert()
	
	_make(content=content, sender=sender, subject = subject,
		doctype="Support Ticket", name=ticket.name,
		date=mail.date if mail else today(), sent_or_received="Received")

	if mail:
		mail.save_attachments_in_doc(ticket)
		
	return ticket
Example #27
0
	def test_make_new_lead_if_required(self):
		args = {
			"doctype": "Opportunity",
			"contact_email":"*****@*****.**",
			"enquiry_type": "Sales",
			"with_items": 0,
			"transaction_date": today()
		}
		# new lead should be created against the [email protected]
		opp_doc = frappe.get_doc(args).insert(ignore_permissions=True)

		self.assertTrue(opp_doc.lead)
		self.assertEquals(opp_doc.enquiry_from, "Lead")
		self.assertEquals(frappe.db.get_value("Lead", opp_doc.lead, "email_id"),
			'*****@*****.**')

		# create new customer and create new contact against '*****@*****.**'
		customer = make_customer(opp_doc.lead).insert(ignore_permissions=True)
		frappe.get_doc({
			"doctype": "Contact",
			"email_id": "*****@*****.**",
			"first_name": "_Test Opportunity Customer",
			"links": [{
				"link_doctype": "Customer",
				"link_name": customer.name
			}]
		}).insert(ignore_permissions=True)

		opp_doc = frappe.get_doc(args).insert(ignore_permissions=True)
		self.assertTrue(opp_doc.customer)
		self.assertEquals(opp_doc.enquiry_from, "Customer")
		self.assertEquals(opp_doc.customer, customer.name)
Example #28
0
	def validate(self):
		if session['user'] != 'Guest' and not self.customer:
			frappe.throw(_("Customer is required"))

		if self.status=="Closed" and \
			frappe.db.get_value("Warranty Claim", self.name, "status")!="Closed":
			self.resolution_date = today()
Example #29
0
def make_auto_repeat_entry(date=None):
	enqueued_method = 'frappe.desk.doctype.auto_repeat.auto_repeat.create_repeated_entries'
	jobs = get_jobs()

	if not jobs or enqueued_method not in jobs[frappe.local.site]:
		date = date or today()
		for data in get_auto_repeat_entries(date):
			frappe.enqueue(enqueued_method, data=data)
Example #30
0
def convert_deferred_revenue_to_income(start_date=None, end_date=None):
	# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
	if not start_date:
		start_date = add_months(today(), -1)
	if not end_date:
		end_date = add_days(today(), -1)

	# check for the sales invoice for which GL entries has to be done
	invoices = frappe.db.sql_list('''
		select distinct parent from `tabSales Invoice Item`
		where service_start_date<=%s and service_end_date>=%s
		and enable_deferred_revenue = 1 and docstatus = 1 and ifnull(amount, 0) > 0
	''', (end_date, start_date))

	for invoice in invoices:
		doc = frappe.get_doc("Sales Invoice", invoice)
		book_deferred_income_or_expense(doc, end_date)
Example #31
0
def make_patient_activity(patient, activity_items, sales_person=None):
    activity_items = json.loads(activity_items)

    patient_activity = frappe.get_doc({
        'doctype': 'Patient Activity',
        'patient': patient,
        'sales_person': sales_person,
        'posting_date': today()
    })

    for activity_item in activity_items:
        patient_activity.append(
            'items', {
                'activity_type': activity_item.get('activity_type'),
                'description': activity_item.get('description'),
                'attach': activity_item.get('attach')
            })

    patient_activity.save()

    return patient_activity
Example #32
0
def send_birthday_wish():
    birthdays = frappe.db.sql(
        """select name,date_of_birth,company_email, employee_name
        from tabEmployee where day(date_of_birth) = day(%(date)s)
        and month(date_of_birth) = month(%(date)s)
        and status = 'Active'""", {"date": today()},
        as_dict=True)
    for r in birthdays:
        print(r)
        wish = frappe.get_doc("Birthday Wishes")
        result = []
        for w in wish.wishes:
            res = w.wishes
            result.append(res)
        s = random.sample(result, 1)
        print(s)
        if birthdays:
            frappe.sendmail(recipients=['r.company_email'],
                            subject="Birthday Wishes for {0}"),
            message = """<p> Dear {1} <br> {2} ,</p>""".format(
                r.employee_name, r.employee_name, s)
Example #33
0
def update_maintenance_status():
    assets = frappe.get_all("Asset",
                            filters={
                                "docstatus": 1,
                                "maintenance_required": 1
                            })

    for asset in assets:
        asset = frappe.get_doc("Asset", asset.name)
        if frappe.db.exists("Asset Repair", {
                "asset_name": asset.name,
                "repair_status": "Pending"
        }):
            asset.set_status("Out of Order")
        elif frappe.db.exists("Asset Maintenance Task", {
                "parent": asset.name,
                "next_due_date": today()
        }):
            asset.set_status("In Maintenance")
        else:
            asset.set_status()
Example #34
0
def update_company_current_month_sales(company):
    current_month_year = formatdate(today(), "MM-yyyy")

    results = frappe.db.sql('''
		select
			sum(base_grand_total) as total, date_format(posting_date, '%m-%Y') as month_year
		from
			`tabSales Invoice`
		where
			date_format(posting_date, '%m-%Y')="{0}"
			and docstatus = 1
			and company = "{1}"
		group by
			month_year
	'''.format(current_month_year, frappe.db.escape(company)),
                            as_dict=True)

    monthly_total = results[0]['total'] if len(results) > 0 else 0

    frappe.db.set_value("Company", company, "total_monthly_sales",
                        monthly_total)
Example #35
0
    def test_disable_scheduler_on_expiry(self):
        update_limits({'expiry': add_to_date(today(), days=-1)})
        frappe.local.conf = _dict(frappe.get_site_config())

        if not frappe.db.exists('User', '*****@*****.**'):
            user = frappe.new_doc('User')
            user.email = '*****@*****.**'
            user.first_name = 'Test_scheduler'
            user.save()
            user.add_roles('System Manager')

        frappe.db.commit()
        frappe.set_user("*****@*****.**")

        disable_scheduler_on_expiry()

        ss = frappe.get_doc("System Settings")
        self.assertFalse(ss.enable_scheduler)

        clear_limit("expiry")
        frappe.local.conf = _dict(frappe.get_site_config())
Example #36
0
def allocate_review_points():
	settings = frappe.get_single('Energy Point Settings')

	if not can_allocate_today(settings.last_point_allocation_date,
		settings.point_allocation_periodicity):
		return

	user_point_map = {}

	for level in settings.review_levels:
		users = get_users_with_role(level.role)
		for user in users:
			user_point_map.setdefault(user, 0)
			# to avoid duplicate point allocation
			user_point_map[user] = max([user_point_map[user], level.review_points])

	for user, points in user_point_map.items():
		create_review_points_log(user, points)

	settings.last_point_allocation_date = today()
	settings.save(ignore_permissions=True)
def execute():
    if frappe.db.exists('DocType', 'Email Campaign'):
        email_campaign = frappe.get_all('Email Campaign')
        for campaign in email_campaign:
            doc = frappe.get_doc("Email Campaign", campaign["name"])
            send_after_days = []

            camp = frappe.get_doc("Campaign", doc.campaign_name)
            for entry in camp.get("campaign_schedules"):
                send_after_days.append(entry.send_after_days)
            if send_after_days:
                end_date = add_days(getdate(doc.start_date),
                                    max(send_after_days))
                doc.db_set("end_date", end_date)
            today_date = getdate(today())
            if doc.start_date > today_date:
                doc.db_set("status", "Scheduled")
            elif end_date >= today_date:
                doc.db_set("status", "In Progress")
            elif end_date < today_date:
                doc.db_set("status", "Completed")
Example #38
0
    def validate_dates(self):
        for sibling in self.siblings:
            if sibling.date_of_birth and getdate(
                    sibling.date_of_birth) > getdate():
                frappe.throw(
                    _("Row {0}:Sibling Date of Birth cannot be greater than today."
                      ).format(sibling.idx))

        if self.date_of_birth and getdate(self.date_of_birth) >= getdate(
                today()):
            frappe.throw(_("Date of Birth cannot be greater than today."))

        if self.date_of_birth and getdate(self.date_of_birth) >= getdate(
                self.joining_date):
            frappe.throw(
                _("Date of Birth cannot be greater than Joining Date."))

        if (self.joining_date and self.date_of_leaving and
                getdate(self.joining_date) > getdate(self.date_of_leaving)):
            frappe.throw(
                _("Joining Date can not be greater than Leaving Date"))
Example #39
0
def get_loyalty_details(customer, loyalty_program, expiry_date=None, company=None, include_expired_entry=False):
	if not expiry_date:
		expiry_date = today()

	condition = ''
	if company:
		condition = " and company='%s' " % frappe.db.escape(company)
	if not include_expired_entry:
		condition += " and expiry_date>='%s' " % expiry_date

	loyalty_point_details = frappe.db.sql('''select sum(loyalty_points) as loyalty_points,
		sum(purchase_amount) as total_spent from `tabLoyalty Point Entry`
		where customer=%s and loyalty_program=%s and posting_date <= %s
		{condition}
		group by customer'''.format(condition=condition),
		(customer, loyalty_program, expiry_date), as_dict=1)

	if loyalty_point_details:
		return loyalty_point_details[0]
	else:
		return {"loyalty_points": 0, "total_spent": 0}
def save_payment_allocation(data):
    if data:
        data = json.loads(data)
        pa = frappe.new_doc("Payment Allocation")
        pa.customer = data.get("customer")
        pa.posting_date = today()

        for k, v in data.get("items", {}).items():
            pa.append(
                "payment_allocation_items", {
                    "item_code": k,
                    "qty": v[0],
                    "rate": v[1],
                    "amount": int(v[0]) * flt(v[1]),
                    "against_sales_order": v[2],
                    "remarks": v[4]
                })
        pa.flags.ignore_permissions = True
        pa.save()
        frappe.db.commit()
        return "Success"
Example #41
0
def get_payment_terms_from_file(file_content):
	terms = []
	#Get mode of payment dict from setup
	mop_options = frappe.get_meta('Mode of Payment').fields[4].options
	mop_str = re.sub('\n', ',', mop_options)
	mop_dict = dict(item.split("-") for item in mop_str.split(","))
	#read file for payment information
	for line in file_content.find_all("DettaglioPagamento"):
		mop_code = line.ModalitaPagamento.text + '-' + mop_dict.get(line.ModalitaPagamento.text)
		if line.find("DataScadenzaPagamento"):
			due_date = dateutil.parser.parse(line.DataScadenzaPagamento.text).strftime("%Y-%m-%d")
		else:
			due_date = today()
		terms.append({
			"mode_of_payment_code": mop_code,
			"bank_account_iban": line.IBAN.text if line.find("IBAN") else "",
			"due_date": due_date,
			"payment_amount": line.ImportoPagamento.text
		})

	return terms
Example #42
0
def save_sales_order_item_for_sd(sid, item_id, item_qty, rate):
    #rate=frappe.db.get("Item",{"name":item_id}).standard_rate

    item_doc = frappe.get_doc({
        "docstatus": 0,
        "doctype": "Sales Order Item",
        "name": "New Sales Order Item 1",
        "__islocal": 1,
        "__unsaved": 1,
        "owner": str(frappe.session.user),
        "parent": str(sid),
        "parentfield": "items",
        "parenttype": "Sales Order",
        "idx": 1,
        "qty": str(item_qty),
        "rate": rate,
        "item_code": str(item_id),
        "update_stock": 0,
        "delivery_date": str(today())
    })
    item_save = item_doc.insert()
    def test_leave_balance_value_and_amount(self):
        frappe.db.sql('''delete from `tabLeave Encashment`''')
        leave_encashment = frappe.get_doc(
            dict(doctype='Leave Encashment',
                 employee=self.employee,
                 leave_type="_Test Leave Type Encashment",
                 leave_period=self.leave_period.name,
                 payroll_date=today(),
                 currency="INR")).insert()

        self.assertEqual(leave_encashment.leave_balance, 10)
        self.assertEqual(leave_encashment.encashable_days, 5)
        self.assertEqual(leave_encashment.encashment_amount, 250)

        leave_encashment.submit()

        # assert links
        add_sal = frappe.get_all(
            "Additional Salary",
            filters={"ref_docname": leave_encashment.name})[0]
        self.assertTrue(add_sal)
Example #44
0
def update_company_current_month_sales(company):
	current_month_year = formatdate(today(), "MM-yyyy")

	results = frappe.db.sql('''
		SELECT
			SUM(base_grand_total) AS total,
			DATE_FORMAT(`posting_date`, '%m-%Y') AS month_year
		FROM
			`tabSales Invoice`
		WHERE
			DATE_FORMAT(`posting_date`, '%m-%Y') = '{current_month_year}'
			AND docstatus = 1
			AND company = {company}
		GROUP BY
			month_year
	'''.format(current_month_year=current_month_year, company=frappe.db.escape(company)),
		as_dict = True)

	monthly_total = results[0]['total'] if len(results) > 0 else 0

	frappe.db.set_value("Company", company, "total_monthly_sales", monthly_total)
Example #45
0
def makeReceivingSheet(master_sales_order):
	to_date=today()
	master_so=frappe.get_doc("Master Sales Order",str(master_sales_order))
	
	if not frappe.db.exists("Master Sales Receiving Mode",str(master_sales_order)):
		data2=frappe.get_doc({
							"docstatus": 0,
							"doctype": "Master Sales Receiving Mode",
							"name": "New Master Sales Receiving Mode 1",
							"master_sales_order": master_sales_order,
							"shipping_date": master_so.shipping_date,
							"delivery_date": master_so.delivery_date,
							"order_type": master_so.order_type,
							"receiving_date": to_date
						})
		d=data2.insert(ignore_permissions=True)
		if d:
			return d.name
	else:
		check_sheet=frappe.get_doc("Receiving Sheet",str(master_sales_order))
		return check_sheet.name		
Example #46
0
def reconcile_dr_cr_note(dr_cr_notes, company):
	for d in dr_cr_notes:
		voucher_type = ('Credit Note'
			if d.voucher_type == 'Sales Invoice' else 'Debit Note')

		reconcile_dr_or_cr = ('debit_in_account_currency'
			if d.dr_or_cr == 'credit_in_account_currency' else 'credit_in_account_currency')

		company_currency = erpnext.get_company_currency(company)

		jv = frappe.get_doc({
			"doctype": "Journal Entry",
			"voucher_type": voucher_type,
			"posting_date": today(),
			"company": company,
			"multi_currency": 1 if d.currency != company_currency else 0,
			"accounts": [
				{
					'account': d.account,
					'party': d.party,
					'party_type': d.party_type,
					d.dr_or_cr: abs(d.allocated_amount),
					'reference_type': d.against_voucher_type,
					'reference_name': d.against_voucher,
					'cost_center': erpnext.get_default_cost_center(company)
				},
				{
					'account': d.account,
					'party': d.party,
					'party_type': d.party_type,
					reconcile_dr_or_cr: (abs(d.allocated_amount)
						if abs(d.unadjusted_amount) > abs(d.allocated_amount) else abs(d.unadjusted_amount)),
					'reference_type': d.voucher_type,
					'reference_name': d.voucher_no,
					'cost_center': erpnext.get_default_cost_center(company)
				}
			]
		})

		jv.submit()
Example #47
0
def update_password(new_password, logout_all_sessions=0, key=None, old_password=None):
	# validate key to avoid key input like ['like', '%'], '', ['in', ['']]
	if key and not isinstance(key, str):
		frappe.throw(_("Invalid key type"))

	result = test_password_strength(new_password, key, old_password)
	feedback = result.get("feedback", None)

	if feedback and not feedback.get("password_policy_validation_passed", False):
		handle_password_test_fail(result)

	res = _get_user_for_update_password(key, old_password)
	if res.get("message"):
		frappe.local.response.http_status_code = 410
		return res["message"]
	else:
		user = res["user"]

	logout_all_sessions = cint(logout_all_sessions) or frappe.db.get_single_value(
		"System Settings", "logout_on_password_reset"
	)
	_update_password(user, new_password, logout_all_sessions=cint(logout_all_sessions))

	user_doc, redirect_url = reset_user_data(user)

	# get redirect url from cache
	redirect_to = frappe.cache().hget("redirect_after_login", user)
	if redirect_to:
		redirect_url = redirect_to
		frappe.cache().hdel("redirect_after_login", user)

	frappe.local.login_manager.login_as(user)

	frappe.db.set_value("User", user, "last_password_reset_date", today())
	frappe.db.set_value("User", user, "reset_password_key", "")

	if user_doc.user_type == "System User":
		return "/app"
	else:
		return redirect_url if redirect_url else "/"
Example #48
0
def process_expired_allocation():
    ''' Check if a carry forwarded allocation has expired and create a expiry ledger entry '''

    # fetch leave type records that has carry forwarded leaves expiry
    leave_type_records = frappe.db.get_values(
        "Leave Type",
        filters={'expire_carry_forwarded_leaves_after_days': (">", 0)},
        fieldname=['name'])

    if leave_type_records:
        leave_type = [record[0] for record in leave_type_records]

        expired_allocation = frappe.db.sql_list("""SELECT name
			FROM `tabLeave Ledger Entry`
			WHERE
				`transaction_type`='Leave Allocation'
				AND `is_expired`=1""")

        expire_allocation = frappe.get_all("Leave Ledger Entry",
                                           fields=[
                                               'leaves', 'to_date', 'employee',
                                               'leave_type',
                                               'is_carry_forward',
                                               'transaction_name as name',
                                               'transaction_type'
                                           ],
                                           filters={
                                               'to_date': ("<", today()),
                                               'transaction_type':
                                               'Leave Allocation',
                                               'transaction_name':
                                               ('not in', expired_allocation)
                                           },
                                           or_filters={
                                               'is_carry_forward': 0,
                                               'leave_type': ('in', leave_type)
                                           })

    if expire_allocation:
        create_expiry_ledger_entry(expire_allocation)
Example #49
0
def create_invoice(customer, billing, shipping, pflanzenfreund_abo, abo):
    sales_invoice = frappe.new_doc("Sales Invoice")
    sales_invoice.update({
        "customer":
        customer,
        "customer_address":
        billing,
        "shipping_address_name":
        shipping,
        "delivery_date":
        utils.today(),
        "pflanzenfreund_abo":
        pflanzenfreund_abo.name,
        "taxes_and_charges":
        "Schweiz normal (302) - GCM",
        "items": [{
            "item_code": abo,
            "qty": "1"
        }],
        "taxes": [{
            "charge_type": "On Net Total",
            "account_head": "2200 - Umsatzsteuer - GCM",
            "cost_center": "Haupt - GCM",
            "rate": "7.7",
            "description": "Inkl. 7.7% MwSt"
        }]
    })
    sales_invoice.flags.ignore_mandatory = True
    sales_invoice.save(ignore_permissions=True)
    referencenumber = sales_invoice.name.split("-")[1]
    sales_invoice.update({
        "esr_reference":
        esr.get_reference_number(referencenumber),
        "esr_code":
        esr.generateCodeline(sales_invoice.grand_total, referencenumber,
                             "013100113")
    })
    sales_invoice.save(ignore_permissions=True)
    sales_invoice.submit()
    frappe.db.commit()
def process_expired_allocation():
    ''' Check if a carry forwarded allocation has expired and create a expiry ledger entry
		Case 1: carry forwarded expiry period is set for the leave type,
			create a separate leave expiry entry against each entry of carry forwarded and non carry forwarded leaves
		Case 2: leave type has no specific expiry period for carry forwarded leaves
			and there is no carry forwarded leave allocation, create a single expiry against the remaining leaves.
	'''

    # fetch leave type records that has carry forwarded leaves expiry
    leave_type_records = frappe.db.get_values(
        "Leave Type",
        filters={'expire_carry_forwarded_leaves_after_days': (">", 0)},
        fieldname=['name'])

    leave_type = [record[0] for record in leave_type_records] or ['']

    # fetch non expired leave ledger entry of transaction_type allocation
    expire_allocation = frappe.db.sql("""
		SELECT
			leaves, to_date, employee, leave_type,
			is_carry_forward, transaction_name as name, transaction_type
		FROM `tabLeave Ledger Entry` l
		WHERE (NOT EXISTS
			(SELECT name
				FROM `tabLeave Ledger Entry`
				WHERE
					transaction_name = l.transaction_name
					AND transaction_type = 'Leave Allocation'
					AND name<>l.name
					AND docstatus = 1
					AND (
						is_carry_forward=l.is_carry_forward
						OR (is_carry_forward = 0 AND leave_type not in %s)
			)))
			AND transaction_type = 'Leave Allocation'
			AND to_date < %s""", (leave_type, today()),
                                      as_dict=1)

    if expire_allocation:
        create_expiry_ledger_entry(expire_allocation)
def get_data(report_filters):

	data = []
	checkmark = []

	if (report_filters.date):
		filters = {
				"status": report_filters.status,
				"date": ['is', report_filters.date],
			}
	else:
		filters = {
				"status": report_filters.status,
			}

	names_of_todo_docs = frappe.get_all("ToDo", filters=filters, fields = ["name","description", "status", "priority", "reference_type", "reference_name","date"],
		order_by = "")
	# print(names_of_todo_docs)

	for entry in names_of_todo_docs:

		# print(entry)

		#### calculate remaining time
		today = utils.today();
		if entry.date:
			datediff = utils.date_diff(entry.date, today)
			entry['days_to_due_date'] = datediff


		if entry.reference_type:
			entry.reference = """<a href="#Form/%s/%s">%s: %s</a>""" % (entry.reference_type,
				entry.reference_name, entry.reference_type, entry.reference_name)
		else:
			entry.reference = None


		data.append(entry)
		
	return data
	def test_multi_uom_for_purchase(self):
		mr = frappe.copy_doc(test_records[0])
		mr.material_request_type = 'Purchase'
		item = mr.items[0]
		mr.schedule_date = today()

		if not frappe.db.get_value('UOM Conversion Detail',
			 {'parent': item.item_code, 'uom': 'Kg'}):
			 item_doc = frappe.get_doc('Item', item.item_code)
			 item_doc.append('uoms', {
				 'uom': 'Kg',
				 'conversion_factor': 5
			 })
			 item_doc.save(ignore_permissions=True)

		item.uom = 'Kg'
		for item in mr.items:
			item.schedule_date = mr.schedule_date

		mr.insert()
		self.assertRaises(frappe.ValidationError, make_purchase_order,
			mr.name)

		mr = frappe.get_doc("Material Request", mr.name)
		mr.submit()
		item = mr.items[0]

		self.assertEqual(item.uom, "Kg")
		self.assertEqual(item.conversion_factor, 5.0)
		self.assertEqual(item.stock_qty, flt(item.qty * 5))

		po = make_purchase_order(mr.name)
		self.assertEqual(po.doctype, "Purchase Order")
		self.assertEqual(len(po.get("items")), len(mr.get("items")))

		po.supplier = '_Test Supplier'
		po.insert()
		po.submit()
		mr = frappe.get_doc("Material Request", mr.name)
		self.assertEqual(mr.per_ordered, 100)
Example #53
0
def get_sal_structure(employee):
    cond = """and sa.employee=%(employee)s and sa.from_date <= %(date)s"""
    st_name = frappe.db.sql(
        """
		select sa.salary_structure
		from `tabSalary Structure Assignment` sa join `tabSalary Structure` ss
		where sa.salary_structure=ss.name
			and sa.docstatus = 1 and ss.docstatus = 1 and ss.is_active ='Yes' %s
		order by sa.from_date desc
		limit 1
	""" % cond, {
            'employee': employee,
            'date': today()
        })

    if st_name:
        return st_name[0][0]
    else:
        frappe.msgprint(_(
            "No active or default Salary Structure found for employee {0} for the given dates"
        ).format(employee),
                        title=_('Salary Structure Missing'))
Example #54
0
    def get_next_schedule_date(self, schedule_date, for_full_schedule=False):
        """
			Returns the next schedule date for auto repeat after a recurring document has been created.
			Adds required offset to the schedule_date param and returns the next schedule date.

			:param schedule_date: The date when the last recurring document was created.
			:param for_full_schedule: If True, returns the immediate next schedule date, else the full schedule.
		"""
        if month_map.get(self.frequency):
            month_count = month_map.get(self.frequency) + month_diff(
                schedule_date, self.start_date) - 1
        else:
            month_count = 0

        day_count = 0
        if month_count and self.repeat_on_last_day:
            day_count = 31
            next_date = get_next_date(self.start_date, month_count, day_count)
        elif month_count and self.repeat_on_day:
            day_count = self.repeat_on_day
            next_date = get_next_date(self.start_date, month_count, day_count)
        elif month_count:
            next_date = get_next_date(self.start_date, month_count)
        else:
            days = self.get_days(schedule_date)
            next_date = add_days(schedule_date, days)

        # next schedule date should be after or on current date
        if not for_full_schedule:
            while getdate(next_date) < getdate(today()):
                if month_count:
                    month_count += month_map.get(self.frequency, 0)
                    next_date = get_next_date(self.start_date, month_count,
                                              day_count)
                else:
                    days = self.get_days(next_date)
                    next_date = add_days(next_date, days)

        return next_date
Example #55
0
    def validate_date(self):
        if self.date_of_birth and getdate(self.date_of_birth) > getdate(
                today()):
            throw(_("Date of Birth cannot be greater than today."))

        if self.date_of_birth and self.date_of_joining and getdate(
                self.date_of_birth) >= getdate(self.date_of_joining):
            throw(_("Date of Joining must be greater than Date of Birth"))

        elif self.date_of_retirement and self.date_of_joining and (getdate(
                self.date_of_retirement) <= getdate(self.date_of_joining)):
            throw(_("Date Of Retirement must be greater than Date of Joining"))

        elif self.relieving_date and self.date_of_joining and (getdate(
                self.relieving_date) < getdate(self.date_of_joining)):
            throw(
                _("Relieving Date must be greater than or equal to Date of Joining"
                  ))

        elif self.contract_end_date and self.date_of_joining and (getdate(
                self.contract_end_date) <= getdate(self.date_of_joining)):
            throw(_("Contract End Date must be greater than Date of Joining"))
 def make_journal_voucher(self):
     doc = frappe.get_doc({
         "doctype": "Journal Entry",
         "voucher_type": "Journal Entry",
         "posting_date": today(),
         "realestate_payment_entry": self.name
     })
     if self.payment_type == "Pay":
         #from
         doc.append(
             "accounts", {
                 "account": self.account_paid_from,
                 "credit_in_account_currency": self.paid_amount
             })
         #to
         doc.append(
             "accounts", {
                 "account": self.account_paid_to,
                 "party_type": "Shareholder",
                 "party": self.shareholder,
                 "debit_in_account_currency": self.paid_amount
             })
     else:
         #to
         doc.append(
             "accounts", {
                 "account": self.account_paid_to,
                 "debit_in_account_currency": self.paid_amount
             })
         #from
         doc.append(
             "accounts", {
                 "account": self.account_paid_from,
                 "party_type": "Shareholder",
                 "party": self.shareholder,
                 "credit_in_account_currency": self.paid_amount
             })
     doc.insert()
     doc.submit()
Example #57
0
def send_project_status_email_to_users():
    yesterday = add_days(today(), -1)

    for d in frappe.get_all("Project Update", {'date': yesterday, 'sent': 0}):
        doc = frappe.get_doc("Project Update", d.name)

        project_doc = frappe.get_doc('Project', doc.project)

        args = {
            "users": doc.users,
            "title": _("Project Summary for {0}").format(yesterday)
        }

        frappe.sendmail(recipients=get_users_email(project_doc),
                        template='daily_project_summary',
                        args=args,
                        subject=_("Daily Project Summary for {0}").format(
                            d.name),
                        reference_doctype="Project Update",
                        reference_name=d.name)

        doc.db_set('sent', 1)
Example #58
0
def save_purchase_order_item(sid, item_id, item_qty):
    #rate=frappe.db.get("Item",{"name":item_id}).standard_rate

    item_doc = frappe.get_doc({
        "docstatus": 0,
        "doctype": "Purchase Order Item",
        "name": "New Purchase Order Item 1",
        "__islocal": 1,
        "__unsaved": 1,
        "owner": str(frappe.session.user),
        "parent": str(sid),
        "parentfield": "items",
        "parenttype": "Sales Order",
        "idx": 1,
        "qty": str(item_qty),
        "item_code": str(item_id),
        "rate": getItemRate(item_id),
        "update_stock": 0,
        "warehouse": "Sundine Kestrel- . - .",
        "delivery_date": str(today())
    })
    item_save = item_doc.insert()
Example #59
0
def saveLandingCostPO(po):
    data = json.loads(po)
    count = 0
    i = 0
    for row1 in data["landing_cost_suppliers"]:

        data3 = frappe.get_doc({
            "docstatus": 1,
            "status": "Draft",
            "doctype": "Purchase Invoice",
            "naming_series": "PINV-",
            "name": "New Purchase Invoice 1",
            "supplier": row1["supplier"],
            "posting_date": today(),
            "due_date": data["arrival_date"],
            "master_po_id": data["master_purchase_order"],
            "idx": 0,
            "items": row1["items"],
            "credit_to": "2100 - CAD Accounts Payable  - ."
        })
        d = data3.insert(ignore_permissions=True)
        count = count + 1
Example #60
0
def update_password(new_password,
                    logout_all_sessions=0,
                    key=None,
                    old_password=None):
    result = test_password_strength(new_password, key, old_password)
    feedback = result.get("feedback", None)

    if feedback and not feedback.get('password_policy_validation_passed',
                                     False):
        handle_password_test_fail(result)

    res = _get_user_for_update_password(key, old_password)
    if res.get('message'):
        frappe.local.response.http_status_code = 410
        return res['message']
    else:
        user = res['user']

    _update_password(user,
                     new_password,
                     logout_all_sessions=int(logout_all_sessions))

    user_doc, redirect_url = reset_user_data(user)

    # get redirect url from cache
    redirect_to = frappe.cache().hget('redirect_after_login', user)
    if redirect_to:
        redirect_url = redirect_to
        frappe.cache().hdel('redirect_after_login', user)

    frappe.local.login_manager.login_as(user)

    frappe.db.set_value("User", user, "last_password_reset_date", today())
    frappe.db.set_value("User", user, "reset_password_key", "")

    if user_doc.user_type == "System User":
        return "/desk"
    else:
        return redirect_url if redirect_url else "/"