Example #1
0
	def test_insert_if_owner_with_user_permissions(self):
		"""If `If Owner` is checked for a Role, check if that document is allowed to be read, updated, submitted, etc. except be created, even if the document is restricted based on User Permissions."""
		self.set_user_permission_doctypes(["Blog Category"])
		self.if_owner_setup()

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

		doc = frappe.get_doc({
			"doctype": "Blog Post",
			"blog_category": "_Test Blog Category",
			"blogger": "_Test Blogger 1",
			"title": "_Test Blog Post Title",
			"content": "_Test Blog Post Content"
		})

		self.assertRaises(frappe.PermissionError, doc.insert)

		frappe.set_user("Administrator")
		frappe.permissions.add_user_permission("Blog Category", "_Test Blog Category",
			"*****@*****.**")

		frappe.set_user("*****@*****.**")
		doc.insert()

		frappe.set_user("Administrator")
		frappe.permissions.remove_user_permission("Blog Category", "_Test Blog Category",
			"*****@*****.**")

		frappe.set_user("*****@*****.**")
		doc = frappe.get_doc(doc.doctype, doc.name)
		self.assertTrue(doc.has_permission("read"))
		self.assertTrue(doc.has_permission("write"))
		self.assertFalse(doc.has_permission("create"))
Example #2
0
def work():
	frappe.set_user(frappe.db.get_global('demo_manufacturing_user'))

	make_purchase_receipt()
	make_delivery_note()
	make_stock_reconciliation()
	submit_draft_stock_entries()
Example #3
0
def run_async_task(self, site=None, user=None, cmd=None, form_dict=None, hijack_std=False):
	ret = {}
	frappe.init(site)
	frappe.connect()

	frappe.local.task_id = self.request.id

	if hijack_std:
		original_stdout, original_stderr = sys.stdout, sys.stderr
		sys.stdout, sys.stderr = get_std_streams(self.request.id)
		frappe.local.stdout, frappe.local.stderr = sys.stdout, sys.stderr

	try:
		set_task_status(self.request.id, "Running")
		frappe.db.commit()
		frappe.set_user(user)
		# sleep(60)
		frappe.local.form_dict = frappe._dict(form_dict)
		execute_cmd(cmd, from_async=True)
		ret = frappe.local.response

	except Exception, e:
		frappe.db.rollback()
		ret = frappe.local.response
		http_status_code = getattr(e, "http_status_code", 500)
		ret['status_code'] = http_status_code
		frappe.errprint(frappe.get_traceback())
		frappe.utils.response.make_logs()
		set_task_status(self.request.id, "Error", response=ret)
		task_logger.error('Exception in running {}: {}'.format(cmd, ret['exc']))
	def tearDown(self):
		frappe.set_user("Administrator")
		set_perpetual_inventory(0)

		for role in ("Stock User", "Sales User"):
			set_user_permission_doctypes(doctype="Stock Entry", role=role,
				apply_user_permissions=0, user_permission_doctypes=None)
	def test_warehouse_user(self):
		set_perpetual_inventory(0)

		for role in ("Stock User", "Sales User"):
			set_user_permission_doctypes(doctype="Stock Entry", role=role,
				apply_user_permissions=1, user_permission_doctypes=["Warehouse"])

		frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission")
		frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission")
		test_user = frappe.get_doc("User", "*****@*****.**")
		test_user.add_roles("Sales User", "Sales Manager", "Stock User")
		test_user.remove_roles("Stock Manager")

		frappe.get_doc("User", "*****@*****.**")\
			.add_roles("Sales User", "Sales Manager", "Stock User", "Stock Manager")

		frappe.set_user("*****@*****.**")
		st1 = frappe.copy_doc(test_records[0])
		st1.company = "_Test Company 1"
		st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1"
		self.assertRaises(frappe.PermissionError, st1.insert)

		frappe.set_user("*****@*****.**")
		st1 = frappe.copy_doc(test_records[0])
		st1.company = "_Test Company 1"
		st1.get("items")[0].t_warehouse="_Test Warehouse 2 - _TC1"
		st1.insert()
		st1.submit()

		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC",
			"*****@*****.**", parenttype="User Permission")
		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1",
			"*****@*****.**", parenttype="User Permission")
Example #6
0
	def test_if_user_is_added(self):
		ev = frappe.get_doc({
			'doctype': 'Event',
			'subject': 'test event for view logs',
			'starts_on': '2018-06-04 14:11:00',
			'event_type': 'Public'
		}).insert()

		frappe.set_user('*****@*****.**')

		from frappe.desk.form.load import getdoc

		# load the form
		getdoc('Event', ev.name)
		a = frappe.get_value(
			doctype="View Log", 
			filters={
				"reference_doctype": "Event",
				"reference_name": ev.name
			}, 
			fieldname=['viewed_by']
		)

		self.assertEqual('*****@*****.**', a)
		self.assertNotEqual('*****@*****.**', a)
    def x_render_page(path):
        log("-- on render_page(%s)" % path)
        try:
            filepath, ext = os.path.splitext(path)
            # we only care about pages
            if ext not in [".js", ".css"]:
                user = frappe.get_user()
                if user.name == "Guest":
                    email = random_string(20) + "@guest.local"
                    user = frappe.get_doc({
                        "doctype": "User",
                        "email": email,
                        "first_name": "Guest User",
                        "enabled": 1,
                        "new_password": random_string(10),
                        "user_type": "Website User"
                    })
                    user.flags.ignore_permissions = True
                    user.insert()
                    frappe.local.login_manager.login_as(user.name)
                    frappe.set_user(user.name)

                log("USER: %s" % user.name)

            result = x_render_page.patched_method(path)
        except Exception as ex:
            log(traceback.format_exc())
            raise ex
        #log(result[0:40] + "...")
        return result
	def test_overlap_with_half_day_3(self):
		self._clear_roles()
		self._clear_applications()

		from frappe.utils.user import add_role
		add_role("*****@*****.**", "Employee")

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

		make_allocation_record()

		# leave from 1-5, half day on 5th
		application = self.get_application(_test_records[0])
		application.half_day = 1
		application.half_day_date = "2013-01-05"
		application.insert()

		# Apply leave from 4-7, half day on 5th
		application = self.get_application(_test_records[0])
		application.from_date = "2013-01-04"
		application.to_date = "2013-01-07"
		application.half_day = 1
		application.half_day_date = "2013-01-05"

		self.assertRaises(OverlapError, application.insert)

		# Apply leave from 5-7, half day on 5th
		application = self.get_application(_test_records[0])
		application.from_date = "2013-01-05"
		application.to_date = "2013-01-07"
		application.half_day = 1
		application.half_day_date = "2013-01-05"
		application.insert()
	def test_overlap_with_half_day(self):
		self._clear_roles()
		self._clear_applications()

		from frappe.utils.user import add_role
		add_role("*****@*****.**", "Employee")
		add_role("*****@*****.**", "Leave Approver")

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

		make_allocation_record()

		# allow second half-day on the same day if available
		application = self.get_application(_test_records[0])
		application.leave_approver = "*****@*****.**"
		application.half_day = 1
		application.insert()

		# allow second half-day on the same day if available
		application = self.get_application(_test_records[0])
		application.leave_approver = "*****@*****.**"
		application.half_day = 1
		application.insert()

		application = self.get_application(_test_records[0])
		application.leave_approver = "*****@*****.**"
		application.half_day = 1

		self.assertRaises(OverlapError, application.insert)
Example #10
0
	def test_warehouse_user(self):
		for role in ("Stock User", "Sales User"):
			set_user_permission_doctypes(doctype="Sales Order", role=role,
				apply_user_permissions=1, user_permission_doctypes=["Warehouse"])

		frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**")
		frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**")
		frappe.permissions.add_user_permission("Company", "_Test Company 1", "*****@*****.**")

		test_user = frappe.get_doc("User", "*****@*****.**")
		test_user.add_roles("Sales User", "Stock User")
		test_user.remove_roles("Sales Manager")

		test_user_2 = frappe.get_doc("User", "*****@*****.**")
		test_user_2.add_roles("Sales User", "Stock User")
		test_user_2.remove_roles("Sales Manager")

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

		so = make_sales_order(company="_Test Company 1",
			warehouse="_Test Warehouse 2 - _TC1", do_not_save=True)
		so.conversion_rate = 0.02
		so.plc_conversion_rate = 0.02
		self.assertRaises(frappe.PermissionError, so.insert)

		frappe.set_user("*****@*****.**")
		so.insert()

		frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**")
		frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**")
		frappe.permissions.remove_user_permission("Company", "_Test Company 1", "*****@*****.**")
Example #11
0
    def tearDown(self):
        frappe.set_user("Administrator")

        for role in ("Stock User", "Sales User"):
            set_user_permission_doctypes(
                doctype="Sales Order", role=role, apply_user_permissions=0, user_permission_doctypes=None
            )
Example #12
0
    def send(self):
        # send email only to enabled users
        valid_users = [
            p[0]
            for p in frappe.db.sql(
                """select name from `tabUser`
			where enabled=1"""
            )
        ]
        recipients = filter(lambda r: r in valid_users, self.recipient_list.split("\n"))

        original_user = frappe.session.user

        if recipients:
            for user_id in recipients:
                frappe.set_user(user_id)
                msg_for_this_receipient = self.get_msg_html()
                if msg_for_this_receipient:
                    frappe.sendmail(
                        recipients=user_id,
                        subject="{frequency} Digest".format(frequency=self.frequency),
                        message=msg_for_this_receipient,
                        bulk=True,
                        reference_doctype=self.doctype,
                        reference_name=self.name,
                        unsubscribe_message=_("Unsubscribe from this Email Digest"),
                    )

        frappe.set_user(original_user)
Example #13
0
	def test_build_match_conditions(self):
		clear_user_permissions_for_doctype('Blog Post', '*****@*****.**')

		test2user = frappe.get_doc('User', '*****@*****.**')
		test2user.add_roles('Blogger')
		frappe.set_user('*****@*****.**')

		# this will get match conditions for Blog Post
		build_match_conditions = DatabaseQuery('Blog Post').build_match_conditions

		# Before any user permission is applied
		# get as filters
		self.assertEqual(build_match_conditions(as_condition=False), [])
		# get as conditions
		self.assertEqual(build_match_conditions(as_condition=True), "")

		add_user_permission('Blog Post', '-test-blog-post', '*****@*****.**', True)
		add_user_permission('Blog Post', '-test-blog-post-1', '*****@*****.**', True)

		# After applying user permission
		# get as filters
		self.assertTrue({'Blog Post': ['-test-blog-post-1', '-test-blog-post']} in build_match_conditions(as_condition=False))
		# get as conditions
		self.assertEqual(build_match_conditions(as_condition=True),
			"""(((ifnull(`tabBlog Post`.`name`, "")="" or `tabBlog Post`.`name` in ("-test-blog-post-1", "-test-blog-post"))))""")

		frappe.set_user('Administrator')
Example #14
0
	def test_warehouse_user(self):
		set_perpetual_inventory(0)

		frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**", "User Permission")
		frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**", "User Permission")
		test_user = frappe.get_doc("User", "*****@*****.**")
		test_user.add_roles("Sales User", "Sales Manager", "Material User")
		test_user.remove_roles("Material Manager")

		frappe.get_doc("User", "*****@*****.**")\
			.add_roles("Sales User", "Sales Manager", "Material User", "Material Manager")

		frappe.set_user("*****@*****.**")
		st1 = frappe.copy_doc(test_records[0])
		st1.company = "_Test Company 1"
		st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1"
		self.assertRaises(frappe.PermissionError, st1.insert)

		frappe.set_user("*****@*****.**")
		st1 = frappe.copy_doc(test_records[0])
		st1.company = "_Test Company 1"
		st1.get("mtn_details")[0].t_warehouse="_Test Warehouse 2 - _TC1"
		st1.insert()
		st1.submit()

		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC",
			"*****@*****.**", parenttype="User Permission")
		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1",
			"*****@*****.**", parenttype="User Permission")
Example #15
0
	def test_warehouse_user(self):
		frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**")
		frappe.permissions.add_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**")
		frappe.permissions.add_user_permission("Company", "_Test Company 1", "*****@*****.**")

		test_user = frappe.get_doc("User", "*****@*****.**")
		test_user.add_roles("Sales User", "Material User")
		test_user.remove_roles("Sales Manager")

		test_user_2 = frappe.get_doc("User", "*****@*****.**")
		test_user_2.add_roles("Sales User", "Material User")
		test_user_2.remove_roles("Sales Manager")

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

		so = frappe.copy_doc(test_records[0])
		so.company = "_Test Company 1"
		so.conversion_rate = 0.02
		so.plc_conversion_rate = 0.02
		so.get("sales_order_details")[0].warehouse = "_Test Warehouse 2 - _TC1"
		self.assertRaises(frappe.PermissionError, so.insert)

		frappe.set_user("*****@*****.**")
		so.insert()

		frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 1 - _TC", "*****@*****.**")
		frappe.permissions.remove_user_permission("Warehouse", "_Test Warehouse 2 - _TC1", "*****@*****.**")
		frappe.permissions.remove_user_permission("Company", "_Test Company 1", "*****@*****.**")
Example #16
0
	def test_clear_user_permissions(self):
		current_user = frappe.session.user
		frappe.set_user('Administrator')
		clear_user_permissions_for_doctype('Blog Category', '*****@*****.**')
		clear_user_permissions_for_doctype('Blog Post', '*****@*****.**')

		add_user_permission('Blog Post', '-test-blog-post-1', '*****@*****.**')
		add_user_permission('Blog Post', '-test-blog-post-2', '*****@*****.**')
		add_user_permission("Blog Category", '_Test Blog Category 1', '*****@*****.**')

		deleted_user_permission_count = clear_user_permissions('*****@*****.**', 'Blog Post')

		self.assertEqual(deleted_user_permission_count, 2)

		blog_post_user_permission_count = frappe.db.count('User Permission', filters={
			'user': '******',
			'allow': 'Blog Post'
		})

		self.assertEqual(blog_post_user_permission_count, 0)

		blog_category_user_permission_count = frappe.db.count('User Permission', filters={
			'user': '******',
			'allow': 'Blog Category'
		})

		self.assertEqual(blog_category_user_permission_count, 1)

		# reset the user
		frappe.set_user(current_user)
Example #17
0
	def tearDown(self):
		frappe.set_user("Administrator")
		frappe.db.set_value("Blogger", "_Test Blogger 1", "user", None)

		clear_user_permissions_for_doctype("Blog Category")
		clear_user_permissions_for_doctype("Blog Post")
		clear_user_permissions_for_doctype("Blogger")
Example #18
0
	def test_employee_salary_slip_read_permission(self):
		self.make_employee("*****@*****.**")

		salary_slip_test_employee = frappe.get_doc("Salary Slip",
			self.make_employee_salary_slip("*****@*****.**", "Monthly"))
		frappe.set_user("*****@*****.**")
		self.assertTrue(salary_slip_test_employee.has_permission("read"))
	def test_global_block_list(self):
		self._clear_roles()

		from frappe.utils.user import add_role
		add_role("*****@*****.**", "Employee")
		add_role("*****@*****.**", "Leave Approver")
		self._add_employee_leave_approver("_T-Employee-0002", "*****@*****.**")
		
		make_allocation_record(employee="_T-Employee-0002")
		
		application = self.get_application(_test_records[1])
		application.leave_approver = "*****@*****.**"

		frappe.db.set_value("Leave Block List", "_Test Leave Block List",
			"applies_to_all_departments", 1)
		frappe.db.set_value("Employee", "_T-Employee-0002", "department",
			"_Test Department")

		frappe.set_user("*****@*****.**")
		application.insert()

		frappe.set_user("*****@*****.**")
		application.status = "Approved"
		self.assertRaises(LeaveDayBlockedError, application.submit)

		frappe.db.set_value("Leave Block List", "_Test Leave Block List",
			"applies_to_all_departments", 0)
	def _test_leave_approval_valid_leave_approver_insert(self):
		self._clear_applications()
		self._add_employee_leave_approver("_T-Employee-0001", "*****@*****.**")

		original_department = frappe.db.get_value("Employee", "_T-Employee-0001", "department")
		frappe.db.set_value("Employee", "_T-Employee-0001", "department", None)

		frappe.set_user("*****@*****.**")
		
		make_allocation_record()
		
		application = self.get_application(_test_records[0])
		application.leave_approver = "*****@*****.**"
		application.insert()

		# change to valid leave approver and try to submit leave application
		frappe.set_user("*****@*****.**")
		application.status = "Approved"
		application.submit()
		self.assertEqual(frappe.db.get_value("Leave Application", application.name,
			"docstatus"), 1)

		frappe.db.sql("""delete from `tabEmployee Leave Approver` where parent=%s""",
			"_T-Employee-0001")

		frappe.db.set_value("Employee", "_T-Employee-0001", "department", original_department)
Example #21
0
	def test_alert_disabled_on_wrong_field(self):
		frappe.set_user('Administrator')
		email_alert = frappe.get_doc({
			"doctype": "Email Alert",
			"subject":"_Test Email Alert for wrong field",
			"document_type": "Event",
			"event": "Value Change",
			"attach_print": 0,
			"value_changed": "description1",
			"message": "Description changed",
			"recipients": [
				{ "email_by_document_field": "owner" }
			]
		}).insert()

		event = frappe.new_doc("Event")
		event.subject = "test-2",
		event.event_type = "Private"
		event.starts_on  = "2014-06-06 12:00:00"
		event.insert()
		event.subject = "test 1"
		event.save()

		# verify that email_alert is disabled
		email_alert.reload()
		self.assertEqual(email_alert.enabled, 0)
		email_alert.delete()
		event.delete()
def update_shopify_settings(shop, session, site_name, email):
	frappe.set_user("Administrator")
	
	shopify_user = frappe.db.sql("""select name from `tabShopify User` 
		where shop_name = %s order by creation desc limit 1""", shop, as_list=1)[0][0]
		
	shopify_user = update_broker_info(shopify_user, email, site_name)
	
	url = "https://{}/api/resource/Shopify Settings/Shopify Settings".format(shopify_user.site_name)
	data = {
		"access_token": shopify_user.access_token,
		"shopify_url": shop,
		"app_type": "Public"
	}

	res = session.put(url, data='data='+json.dumps(data), headers={'content-type': 'application/x-www-form-urlencoded'})

	if res.status_code == 200:
		url = "https://{}/api/method/logout".format(shopify_user.site_name)
		res = session.get(url)
		
		return {"redirect": "https://{}/admin/apps".format(shop)}
		
	else:
		return {"error": _("Something went wrong. Please try again.")}
Example #23
0
	def test_date_changed(self):
		event = frappe.new_doc("Event")
		event.subject = "test",
		event.event_type = "Private"
		event.starts_on = "2014-01-01 12:00:00"
		event.insert()

		self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event",
			"reference_name": event.name, "status":"Not Sent"}))

		frappe.set_user('Administrator')
		frappe.utils.scheduler.trigger(frappe.local.site, "daily", now=True)

		# not today, so no alert
		self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event",
			"reference_name": event.name, "status":"Not Sent"}))

		event.starts_on  = frappe.utils.add_days(frappe.utils.nowdate(), 2) + " 12:00:00"
		event.save()

		# Value Change email alert alert will be trigger as description is not changed
		# mail will not be sent
		self.assertFalse(frappe.db.get_value("Email Queue", {"reference_doctype": "Event",
			"reference_name": event.name, "status":"Not Sent"}))

		frappe.utils.scheduler.trigger(frappe.local.site, "daily", now=True)

		# today so show alert
		self.assertTrue(frappe.db.get_value("Email Queue", {"reference_doctype": "Event",
			"reference_name": event.name, "status":"Not Sent"}))
Example #24
0
def make():
	#frappe.flags.print_messages = True
	frappe.flags.mute_emails = True
	setup()
	frappe.set_user("Administrator")
	frappe.flags.rollback_on_exception = True
	simulate()
Example #25
0
	def test_strict_user_permissions(self):
		"""If `Strict User Permissions` is checked in System Settings,
			show records even if User Permissions are missing for a linked
			doctype"""

		frappe.set_user("Administrator")
		frappe.db.sql('delete from tabContact')
		make_test_records_for_doctype('Contact', force=True)

		set_user_permission_doctypes("Contact", role="Sales User",
			apply_user_permissions=1, user_permission_doctypes=['Salutation'])
		set_user_permission_doctypes("Salutation", role="All",
			apply_user_permissions=1, user_permission_doctypes=['Salutation'])

		add_user_permission("Salutation", "Mr", "*****@*****.**")
		self.set_strict_user_permissions(0)

		frappe.set_user("*****@*****.**")
		self.assertEquals(len(frappe.get_list("Contact")), 2)

		frappe.set_user("Administrator")
		self.set_strict_user_permissions(1)

		frappe.set_user("*****@*****.**")
		self.assertTrue(len(frappe.get_list("Contact")), 1)

		frappe.set_user("Administrator")
		self.set_strict_user_permissions(0)
Example #26
0
def work():
	frappe.set_user(frappe.db.get_global('demo_sales_user_2'))
	if random.random() < 0.5:
		for i in xrange(random.randint(1,7)):
			make_opportunity()

	if random.random() < 0.5:
		for i in xrange(random.randint(1,3)):
			make_quotation()

	# lost quotations / inquiries
	if random.random() < 0.3:
		for i in xrange(random.randint(1,3)):
			quotation = get_random('Quotation', doc=True)
			if quotation and quotation.status == 'Submitted':
				quotation.declare_order_lost('Did not ask')

		for i in xrange(random.randint(1,3)):
			opportunity = get_random('Opportunity', doc=True)
			if opportunity and opportunity.status in ('Open', 'Replied'):
				opportunity.declare_enquiry_lost('Did not ask')

	if random.random() < 0.3:
		for i in xrange(random.randint(1,3)):
			make_sales_order()
Example #27
0
def run_async_task(self, site, user, cmd, form_dict):
	ret = {}
	frappe.init(site)
	frappe.connect()
	sys.stdout, sys.stderr = get_std_streams(self.request.id)
	frappe.local.stdout, frappe.local.stderr = sys.stdout, sys.stderr
	frappe.local.task_id = self.request.id
	frappe.cache()
	try:
		set_task_status(self.request.id, "Running")
		frappe.db.commit()
		frappe.set_user(user)
		# sleep(60)
		frappe.local.form_dict = frappe._dict(form_dict)
		execute_cmd(cmd, from_async=True)
		ret = frappe.local.response
	except Exception, e:
		frappe.db.rollback()
		if not frappe.flags.in_test:
			frappe.db.commit()

		ret = frappe.local.response
		http_status_code = getattr(e, "http_status_code", 500)
		ret['status_code'] = http_status_code
		frappe.errprint(frappe.get_traceback())
		frappe.utils.response.make_logs()
		set_task_status(self.request.id, "Failed", response=ret)
		task_logger.error('Exception in running {}: {}'.format(cmd, ret['exc']))
	def test_block_list(self):
		self._clear_roles()

		from frappe.utils.user import add_role
		add_role("*****@*****.**", "HR User")
		add_role("*****@*****.**", "Leave Approver")
		clear_user_permissions_for_doctype("Employee")

		frappe.db.set_value("Department", "_Test Department",
			"leave_block_list", "_Test Leave Block List")
			
		make_allocation_record()

		application = self.get_application(_test_records[0])
		application.insert()
		application.status = "Approved"
		self.assertRaises(LeaveDayBlockedError, application.submit)

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

		# clear other applications
		frappe.db.sql("delete from `tabLeave Application`")

		application = self.get_application(_test_records[0])
		self.assertTrue(application.insert())
Example #29
0
	def test_event_list(self):
		frappe.set_user("*****@*****.**")
		res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"])
		self.assertEquals(len(res), 2)
		subjects = [r.subject for r in res]
		self.assertTrue("_Test Event 1" in subjects)
		self.assertTrue("_Test Event 3" in subjects)
		self.assertFalse("_Test Event 2" in subjects)
Example #30
0
	def set_as_paid(self):
		if frappe.session.user == "Guest":
			frappe.set_user("Administrator")

		payment_entry = self.create_payment_entry()
		self.make_invoice()

		return payment_entry
Example #31
0
	def login_as_new_user(self):
		self.create_user_if_not_exists("*****@*****.**")
		frappe.set_user("*****@*****.**")
Example #32
0
	def login_as_customer(
		self, email="*****@*****.**", name="_Test Contact For _Test Customer"
	):
		self.create_user_if_not_exists(email, name)
		frappe.set_user(email)
Example #33
0
	def tearDown(self):
		frappe.db.rollback()
		frappe.set_user("Administrator")
		self.disable_shopping_cart()
 def setUp(self):
     frappe.set_user("Administrator")
     create_test_data()
 def tearDown(self):
     frappe.set_user("Administrator")
     delete_test_data()
Example #36
0
    def test_date_changed(self):

        event = frappe.new_doc("Event")
        event.subject = "test",
        event.event_type = "Private"
        event.starts_on = "2014-01-01 12:00:00"
        event.insert()

        self.assertFalse(
            frappe.db.get_value(
                "Email Queue", {
                    "reference_doctype": "Event",
                    "reference_name": event.name,
                    "status": "Not Sent"
                }))

        frappe.set_user('Administrator')
        frappe.get_doc(
            'Scheduled Job Type',
            dict(
                method=
                'frappe.email.doctype.notification.notification.trigger_daily_alerts'
            )).execute()

        # not today, so no alert
        self.assertFalse(
            frappe.db.get_value(
                "Email Queue", {
                    "reference_doctype": "Event",
                    "reference_name": event.name,
                    "status": "Not Sent"
                }))

        event.starts_on = frappe.utils.add_days(frappe.utils.nowdate(),
                                                2) + " 12:00:00"
        event.save()

        # Value Change notification alert will be trigger as description is not changed
        # mail will not be sent
        self.assertFalse(
            frappe.db.get_value(
                "Email Queue", {
                    "reference_doctype": "Event",
                    "reference_name": event.name,
                    "status": "Not Sent"
                }))

        frappe.get_doc(
            'Scheduled Job Type',
            dict(
                method=
                'frappe.email.doctype.notification.notification.trigger_daily_alerts'
            )).execute()

        # today so show alert
        self.assertTrue(
            frappe.db.get_value(
                "Email Queue", {
                    "reference_doctype": "Event",
                    "reference_name": event.name,
                    "status": "Not Sent"
                }))
Example #37
0
 def setUp(self):
     frappe.db.sql("""delete from `tabEmail Queue`""")
     frappe.set_user("*****@*****.**")
 def tearDown(self):
     frappe.set_user('Administrator')
     frappe.db.sql('DELETE FROM `tabEnergy Point Log`')
     frappe.db.sql('DELETE FROM `tabEnergy Point Rule`')
     frappe.cache().delete_value('energy_point_rule_map')
Example #39
0
 def tearDown(self):
     frappe.db.set_value("HR Settings", "HR Settings",
                         "include_holidays_in_total_working_days", 0)
     frappe.set_user("Administrator")
Example #40
0
def work():
    if random.random() < 0.3: return

    frappe.set_user(frappe.db.get_global('demo_manufacturing_user'))
    frappe.set_user_lang(frappe.db.get_global('demo_manufacturing_user'))
    if not frappe.get_all('Sales Order'): return

    from erpnext.projects.doctype.timesheet.timesheet import OverlapError

    ppt = frappe.new_doc("Production Plan")
    ppt.company = erpnext.get_default_company()
    # ppt.use_multi_level_bom = 1 #refactored
    ppt.get_items_from = "Sales Order"
    # ppt.purchase_request_for_warehouse = "Stores - WP" # refactored
    ppt.run_method("get_open_sales_orders")
    if not ppt.get("sales_orders"): return
    ppt.run_method("get_items")
    ppt.run_method("raise_material_requests")
    ppt.save()
    ppt.submit()
    ppt.run_method("raise_work_orders")
    frappe.db.commit()

    # submit work orders
    for pro in frappe.db.get_values("Work Order", {"docstatus": 0}, "name"):
        b = frappe.get_doc("Work Order", pro[0])
        b.wip_warehouse = "Work in Progress - WP"
        b.submit()
        frappe.db.commit()

    # submit material requests
    for pro in frappe.db.get_values("Material Request", {"docstatus": 0},
                                    "name"):
        b = frappe.get_doc("Material Request", pro[0])
        b.submit()
        frappe.db.commit()

    # stores -> wip
    if random.random() < 0.4:
        for pro in query_report.run("Open Work Orders")[
                "result"][:how_many("Stock Entry for WIP")]:
            make_stock_entry_from_pro(pro[0],
                                      "Material Transfer for Manufacture")

    # wip -> fg
    if random.random() < 0.4:
        for pro in query_report.run("Work Orders in Progress")[
                "result"][:how_many("Stock Entry for FG")]:
            make_stock_entry_from_pro(pro[0], "Manufacture")

    for bom in frappe.get_all('BOM',
                              fields=['item'],
                              filters={'with_operations': 1}):
        pro_order = make_wo_order_test_record(
            item=bom.item,
            qty=2,
            source_warehouse=_("Stores") + " - WP",
            wip_warehouse=_("Work in Progress") + " - WP",
            fg_warehouse=_("Stores") + " - WP",
            company=erpnext.get_default_company(),
            stock_uom=frappe.db.get_value('Item', bom.item, 'stock_uom'),
            planned_start_date=get_datetime(frappe.flags.current_date))

    # submit job card
    if random.random() < 0.4:
        submit_job_cards()
 def tearDown(self):
     frappe.set_user("Administrator")
Example #42
0
 def test_permission(self):
     frappe.set_user("Guest")
     self.assertRaises(frappe.PermissionError, self.test_insert)
     frappe.set_user("Administrator")
Example #43
0
	def remove_test_quotation(self, quotation):
		frappe.set_user("Administrator")
		quotation.delete()
    def tearDown(self):
        frappe.set_user("Administrator")

        # so that this test doesn't affect other tests
        frappe.db.sql("""delete from `tabEmployee Leave Approver`""")
 def tearDown(self):
     frappe.set_user("Administrator")
     set_perpetual_inventory(0)
Example #46
0
    def test_gstr_3b_report(self):

        month_number_mapping = {
            1: "January",
            2: "February",
            3: "March",
            4: "April",
            5: "May",
            6: "June",
            7: "July",
            8: "August",
            9: "September",
            10: "October",
            11: "November",
            12: "December"
        }

        frappe.set_user("Administrator")

        frappe.db.sql(
            "delete from `tabSales Invoice` where company='_Test Company GST'")
        frappe.db.sql(
            "delete from `tabPurchase Invoice` where company='_Test Company GST'"
        )
        frappe.db.sql(
            "delete from `tabGSTR 3B Report` where company='_Test Company GST'"
        )

        make_company()
        make_item("Milk",
                  properties={
                      "is_nil_exempt": 1,
                      "standard_rate": 0.000000
                  })
        set_account_heads()
        make_customers()
        make_suppliers()
        make_sales_invoice()
        create_purchase_invoices()

        if frappe.db.exists("GSTR 3B Report",
                            "GSTR3B-March-2019-_Test Address-Billing"):
            report = frappe.get_doc("GSTR 3B Report",
                                    "GSTR3B-March-2019-_Test Address-Billing")
            report.save()
        else:
            report = frappe.get_doc({
                "doctype":
                "GSTR 3B Report",
                "company":
                "_Test Company GST",
                "company_address":
                "_Test Address-Billing",
                "year":
                getdate().year,
                "month":
                month_number_mapping.get(getdate().month)
            }).insert()

        output = json.loads(report.json_output)

        self.assertEqual(output["sup_details"]["osup_det"]["iamt"], 36),
        self.assertEqual(output["sup_details"]["osup_zero"]["iamt"], 18),
        self.assertEqual(output["inter_sup"]["unreg_details"][0]["iamt"], 18),
        self.assertEqual(output["sup_details"]["osup_nil_exmp"]["txval"], 100),
        self.assertEqual(output["inward_sup"]["isup_details"][0]["inter"], 250)
        self.assertEqual(output["itc_elg"]["itc_avl"][4]["samt"], 22.50)
        self.assertEqual(output["itc_elg"]["itc_avl"][4]["camt"], 22.50)
Example #47
0
 def test_allowed_public(self):
     frappe.set_user("*****@*****.**")
     doc = frappe.get_doc(
         "Gate Register",
         frappe.db.get_value("Gate Register",
                             {"company": "Kaynes Technology - 01"}))
Example #48
0
def add_payments():
    if frappe.flags.test_payments_created:
        return

    frappe.set_user("Administrator")

    try:
        frappe.get_doc({
            "doctype": "Supplier",
            "supplier_group": "All Supplier Groups",
            "supplier_type": "Company",
            "supplier_name": "Conrad Electronic"
        }).insert()

    except frappe.DuplicateEntryError:
        pass

    pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690)
    pe = get_payment_entry("Purchase Invoice",
                           pi.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Conrad Oct 18"
    pe.reference_date = "2018-10-24"
    pe.insert()
    pe.submit()

    try:
        frappe.get_doc({
            "doctype": "Supplier",
            "supplier_group": "All Supplier Groups",
            "supplier_type": "Company",
            "supplier_name": "Mr G"
        }).insert()
    except frappe.DuplicateEntryError:
        pass

    pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200)
    pe = get_payment_entry("Purchase Invoice",
                           pi.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Herr G Oct 18"
    pe.reference_date = "2018-10-24"
    pe.insert()
    pe.submit()

    pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700)
    pe = get_payment_entry("Purchase Invoice",
                           pi.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Herr G Nov 18"
    pe.reference_date = "2018-11-01"
    pe.insert()
    pe.submit()

    try:
        frappe.get_doc({
            "doctype": "Supplier",
            "supplier_group": "All Supplier Groups",
            "supplier_type": "Company",
            "supplier_name": "Poore Simon's"
        }).insert()
    except frappe.DuplicateEntryError:
        pass

    try:
        frappe.get_doc({
            "doctype": "Customer",
            "customer_group": "All Customer Groups",
            "customer_type": "Company",
            "customer_name": "Poore Simon's"
        }).insert()
    except frappe.DuplicateEntryError:
        pass

    pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900)
    pe = get_payment_entry("Purchase Invoice",
                           pi.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Poore Simon's Oct 18"
    pe.reference_date = "2018-10-28"
    pe.insert()
    pe.submit()

    si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900)
    pe = get_payment_entry("Sales Invoice",
                           si.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Poore Simon's Oct 18"
    pe.reference_date = "2018-10-28"
    pe.insert()
    pe.submit()

    try:
        frappe.get_doc({
            "doctype": "Customer",
            "customer_group": "All Customer Groups",
            "customer_type": "Company",
            "customer_name": "Fayva"
        }).insert()
    except frappe.DuplicateEntryError:
        pass

    si = create_sales_invoice(customer="Fayva", qty=1, rate=109080)
    pe = get_payment_entry("Sales Invoice",
                           si.name,
                           bank_account="_Test Bank - _TC")
    pe.reference_no = "Fayva Oct 18"
    pe.reference_date = "2018-10-29"
    pe.insert()
    pe.submit()

    mode_of_payment = frappe.get_doc({
        "doctype": "Mode of Payment",
        "name": "Cash"
    })

    if not frappe.db.get_value('Mode of Payment Account', {
            'company': "_Test Company",
            'parent': "Cash"
    }):
        mode_of_payment.append("accounts", {
            "company": "_Test Company",
            "default_account": "_Test Bank - _TC"
        })
        mode_of_payment.save()

    si = create_sales_invoice(customer="Fayva",
                              qty=1,
                              rate=109080,
                              do_not_submit=1)
    si.is_pos = 1
    si.append("payments", {
        "mode_of_payment": "Cash",
        "account": "_Test Bank - _TC",
        "amount": 109080
    })
    si.save()
    si.submit()

    frappe.flags.test_payments_created = True
Example #49
0
 def tearDown(self):
     frappe.set_user("*****@*****.**")
Example #50
0
def add_transactions():
    if frappe.flags.test_bank_transactions_created:
        return

    frappe.set_user("Administrator")
    create_bank_account()

    doc = frappe.get_doc({
        "doctype": "Bank Transaction",
        "description":
        "1512567 BG/000002918 OPSKATTUZWXXX AT776000000098709837 Herr G",
        "date": "2018-10-23",
        "debit": 1200,
        "currency": "INR",
        "bank_account": "Checking Account - Citi Bank"
    }).insert()
    doc.submit()

    doc = frappe.get_doc({
        "doctype": "Bank Transaction",
        "description":
        "1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G",
        "date": "2018-10-23",
        "debit": 1700,
        "currency": "INR",
        "bank_account": "Checking Account - Citi Bank"
    }).insert()
    doc.submit()

    doc = frappe.get_doc({
        "doctype": "Bank Transaction",
        "description":
        "Re 95282925234 FE/000002917 AT171513000281183046 Conrad Electronic",
        "date": "2018-10-26",
        "debit": 690,
        "currency": "INR",
        "bank_account": "Checking Account - Citi Bank"
    }).insert()
    doc.submit()

    doc = frappe.get_doc({
        "doctype": "Bank Transaction",
        "description":
        "Auszahlung Karte MC/000002916 AUTOMAT 698769 K002 27.10. 14:07",
        "date": "2018-10-27",
        "debit": 3900,
        "currency": "INR",
        "bank_account": "Checking Account - Citi Bank"
    }).insert()
    doc.submit()

    doc = frappe.get_doc({
        "doctype": "Bank Transaction",
        "description":
        "I2015000011 VD/000002514 ATWWXXX AT4701345000003510057 Bio",
        "date": "2018-10-27",
        "credit": 109080,
        "currency": "INR",
        "bank_account": "Checking Account - Citi Bank"
    }).insert()
    doc.submit()

    frappe.flags.test_bank_transactions_created = True
Example #51
0
 def test_portal(self):
     self.send_newsletter(1)
     frappe.set_user("*****@*****.**")
     from frappe.email.doctype.newsletter.newsletter import get_newsletter_list
     newsletters = get_newsletter_list("Newsletter", None, None, 0)
     self.assertEquals(len(newsletters), 1)
Example #52
0
 def test_permission_single(self):
     frappe.set_user("Guest")
     d = frappe.get_doc("Website Settings", "Website Settigns")
     self.assertRaises(frappe.PermissionError, d.save)
     frappe.set_user("Administrator")
Example #53
0
def execute_job(site,
                method,
                event,
                job_name,
                kwargs,
                user=None,
                is_async=True,
                retry=0):
    """Executes job in a worker, performs commit/rollback and logs if there is any error"""
    if is_async:
        frappe.connect(site)
        if os.environ.get("CI"):
            frappe.flags.in_test = True

        if user:
            frappe.set_user(user)

    if isinstance(method, string_types):
        method_name = method
        method = frappe.get_attr(method)
    else:
        method_name = cstr(method.__name__)

    frappe.monitor.start("job", method_name, kwargs)
    try:
        method(**kwargs)

    except (frappe.db.InternalError, frappe.RetryBackgroundJobError) as e:
        frappe.db.rollback()

        if retry < 5 and (isinstance(e, frappe.RetryBackgroundJobError) or
                          (frappe.db.is_deadlocked(e)
                           or frappe.db.is_timedout(e))):
            # retry the job if
            # 1213 = deadlock
            # 1205 = lock wait timeout
            # or RetryBackgroundJobError is explicitly raised
            frappe.destroy()
            time.sleep(retry + 1)

            return execute_job(site,
                               method,
                               event,
                               job_name,
                               kwargs,
                               is_async=is_async,
                               retry=retry + 1)

        else:
            frappe.log_error(title=method_name)
            raise

    except:
        frappe.db.rollback()
        frappe.log_error(title=method_name)
        frappe.db.commit()
        print(frappe.get_traceback())
        raise

    else:
        frappe.db.commit()

    finally:
        frappe.monitor.stop()
        if is_async:
            frappe.destroy()
def test_create_test_data():
	frappe.set_user("Administrator")
	# create test item
	if not frappe.db.exists("Item","_Test Tesla Car"):
		item = frappe.get_doc({
		"description": "_Test Tesla Car",
		"doctype": "Item",
		"has_batch_no": 0,
		"has_serial_no": 0,
		"inspection_required": 0,
		"is_stock_item": 1,
		"opening_stock":100,
		"is_sub_contracted_item": 0,
		"item_code": "_Test Tesla Car",
		"item_group": "_Test Item Group",
		"item_name": "_Test Tesla Car",
		"apply_warehouse_wise_reorder_level": 0,
		"warehouse":"Stores - _TC",
		"gst_hsn_code": "999800",
		"valuation_rate": 5000,
		"standard_rate":5000,
		"item_defaults": [{
		"company": "_Test Company",
		"default_warehouse": "Stores - _TC",
		"default_price_list":"_Test Price List",
		"expense_account": "Cost of Goods Sold - _TC",
		"buying_cost_center": "Main - _TC",
		"selling_cost_center": "Main - _TC",
		"income_account": "Sales - _TC"
		}],
		"show_in_website": 1,
		"route":"-test-tesla-car",
		"website_warehouse": "Stores - _TC"
		})
		item.insert()
	# create test item price
	item_price = frappe.get_list('Item Price', filters={'item_code': '_Test Tesla Car', 'price_list': '_Test Price List'}, fields=['name'])
	if len(item_price)==0:
		item_price = frappe.get_doc({
			"doctype": "Item Price",
			"item_code": "_Test Tesla Car",
			"price_list": "_Test Price List",
			"price_list_rate": 5000
		})
		item_price.insert()
	# create test item pricing rule
	if not frappe.db.exists("Pricing Rule","_Test Pricing Rule for _Test Item"):
		item_pricing_rule = frappe.get_doc({
		"doctype": "Pricing Rule",
		"title": "_Test Pricing Rule for _Test Item",
		"apply_on": "Item Code",
		"items": [{
			"item_code": "_Test Tesla Car"
		}],
		"warehouse":"Stores - _TC",
		"coupon_code_based":1,
		"selling": 1,
		"rate_or_discount": "Discount Percentage",
		"discount_percentage": 30,
		"company": "_Test Company",
		"currency":"INR",
		"for_price_list":"_Test Price List"
		})
		item_pricing_rule.insert()
	# create test item sales partner
	if not frappe.db.exists("Sales Partner","_Test Coupon Partner"):
		sales_partner = frappe.get_doc({
		"doctype": "Sales Partner",
		"partner_name":"_Test Coupon Partner",
		"commission_rate":2,
		"referral_code": "COPART"
		})
		sales_partner.insert()
	# create test item coupon code
	if not frappe.db.exists("Coupon Code", "SAVE30"):
		coupon_code = frappe.get_doc({
		"doctype": "Coupon Code",
		"coupon_name":"SAVE30",
		"coupon_code":"SAVE30",
		"pricing_rule": "_Test Pricing Rule for _Test Item",
		"valid_from": "2014-01-01",
		"maximum_use":1,
		"used":0
		})
		coupon_code.insert()
Example #55
0
 def tearDown(self):
     frappe.set_user("Administrator")
     set_perpetual_inventory(0)
     if hasattr(self, "old_default_company"):
         frappe.db.set_default("company", self.old_default_company)
Example #56
0
	def tearDown(self):
		# disable password strength test
		frappe.db.set_value("System Settings", "System Settings", "enable_password_policy", 0)
		frappe.db.set_value("System Settings", "System Settings", "minimum_password_score", "")
		frappe.db.set_value("System Settings", "System Settings", "password_reset_limit", 3)
		frappe.set_user('Administrator')
Example #57
0
 def test_set_user_permissions(self):
     frappe.set_user("*****@*****.**")
     add("*****@*****.**", "Blog Post", "-test-blog-post")
 def __enter__(self):
     frappe.init(site=self.site)
     frappe.connect()
     print frappe.local.site
     frappe.set_user(self.user)
Example #59
0
    def test_not_allowed_to_set_user_permissions(self):
        frappe.set_user("*****@*****.**")

        # this user can't add user permissions
        self.assertRaises(frappe.PermissionError, add, "*****@*****.**",
                          "Blog Post", "-test-blog-post")
Example #60
0
def work():
    frappe.set_user(frappe.db.get_global("demo_hr_user"))
    year, month = frappe.flags.current_date.strftime("%Y-%m").split("-")
    setup_department_approvers()
    mark_attendance()
    make_leave_application()

    # payroll entry
    if not frappe.db.sql(
            "select name from `tabSalary Slip` where month(adddate(start_date, interval 1 month))=month(curdate())"
    ):
        # based on frequency
        payroll_entry = get_payroll_entry()
        payroll_entry.salary_slip_based_on_timesheet = 0
        payroll_entry.save()
        payroll_entry.create_salary_slips()
        payroll_entry.submit_salary_slips()
        payroll_entry.make_accrual_jv_entry()
        payroll_entry.submit()
        # payroll_entry.make_journal_entry(reference_date=frappe.flags.current_date,
        # 	reference_number=random_string(10))

        # based on timesheet
        payroll_entry = get_payroll_entry()
        payroll_entry.salary_slip_based_on_timesheet = 1
        payroll_entry.save()
        payroll_entry.create_salary_slips()
        payroll_entry.submit_salary_slips()
        payroll_entry.make_accrual_jv_entry()
        payroll_entry.submit()
        # payroll_entry.make_journal_entry(reference_date=frappe.flags.current_date,
        # 	reference_number=random_string(10))

    if frappe.db.get_global("demo_hr_user"):
        make_timesheet_records()

        # expense claim
        expense_claim = frappe.new_doc("Expense Claim")
        expense_claim.extend("expenses", get_expenses())
        expense_claim.employee = get_random("Employee")
        expense_claim.company = frappe.flags.company
        expense_claim.payable_account = get_payable_account(
            expense_claim.company)
        expense_claim.posting_date = frappe.flags.current_date
        expense_claim.expense_approver = frappe.db.get_global("demo_hr_user")
        expense_claim.save()

        rand = random.random()

        if rand < 0.4:
            update_sanctioned_amount(expense_claim)
            expense_claim.approval_status = "Approved"
            expense_claim.submit()

            if random.randint(0, 1):
                # make journal entry against expense claim
                je = frappe.get_doc(
                    make_bank_entry("Expense Claim", expense_claim.name))
                je.posting_date = frappe.flags.current_date
                je.cheque_no = random_string(10)
                je.cheque_date = frappe.flags.current_date
                je.flags.ignore_permissions = 1
                je.submit()