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
示例#2
0
文件: hr.py 项目: Aravinthu/erpnext
def work():
	frappe.set_user(frappe.db.get_global('demo_hr_user'))
	year, month = frappe.flags.current_date.strftime("%Y-%m").split("-")
	
	mark_attendance()
	make_leave_application()

	# process payroll
	if not frappe.db.get_value("Salary Slip", {"month": month, "fiscal_year": year}):
		process_payroll = frappe.get_doc("Process Payroll", "Process Payroll")
		process_payroll.company = frappe.flags.company
		process_payroll.month = month
		process_payroll.fiscal_year = year
		process_payroll.create_sal_slip()
		process_payroll.submit_salary_slip()
		r = process_payroll.make_journal_entry(frappe.get_value('Account',
			{'account_name': 'Salary'}))

		journal_entry = frappe.get_doc(r)
		journal_entry.cheque_no = random_string(10)
		journal_entry.cheque_date = frappe.flags.current_date
		journal_entry.posting_date = frappe.flags.current_date
		journal_entry.insert()
		journal_entry.submit()
	
	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.posting_date = frappe.flags.current_date
		expense_claim.exp_approver = filter((lambda x: x[0] != 'Administrator'), get_expense_approver(None, '', None, 0, 20, None))[0][0]
		expense_claim.insert()

		rand = random.random()

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

			if random.randint(0, 1):
				#make journal entry against expense claim
				je = frappe.get_doc(make_bank_entry(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()

		elif rand < 0.2:
			expense_claim.approval_status = "Rejected"
			expense_claim.submit()
示例#3
0
def run_accounts(current_date):
	if can_make("Sales Invoice"):
		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
		report = "Ordered Items to be Billed"
		for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Sales Invoice")]:
			si = frappe.get_doc(make_sales_invoice(so))
			si.posting_date = current_date
			si.fiscal_year = cstr(current_date.year)
			for d in si.get("entries"):
				if not d.income_account:
					d.income_account = "Sales - {}".format(company_abbr)
			si.insert()
			si.submit()
			frappe.db.commit()

	if can_make("Purchase Invoice"):
		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
		report = "Received Items to be Billed"
		for pr in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Invoice")]:
			pi = frappe.get_doc(make_purchase_invoice(pr))
			pi.posting_date = current_date
			pi.fiscal_year = cstr(current_date.year)
			pi.bill_no = random_string(6)
			pi.insert()
			pi.submit()
			frappe.db.commit()
			
	if can_make("Payment Received"):
		from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_sales_invoice
		report = "Accounts Receivable"
		for si in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Sales Invoice"]))[:how_many("Payment Received")]:
			jv = frappe.get_doc(get_payment_entry_from_sales_invoice(si))
			jv.posting_date = current_date
			jv.cheque_no = random_string(6)
			jv.cheque_date = current_date
			jv.fiscal_year = cstr(current_date.year)
			jv.insert()
			jv.submit()
			frappe.db.commit()
			
	if can_make("Payment Made"):
		from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_purchase_invoice
		report = "Accounts Payable"
		for pi in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Purchase Invoice"]))[:how_many("Payment Made")]:
			jv = frappe.get_doc(get_payment_entry_from_purchase_invoice(pi))
			jv.posting_date = current_date
			jv.cheque_no = random_string(6)
			jv.cheque_date = current_date
			jv.fiscal_year = cstr(current_date.year)
			jv.insert()
			jv.submit()
			frappe.db.commit()
示例#4
0
文件: login.py 项目: skhendake/phr
def send_welcome_mail(password,profile_id,args, send_sms=True, is_provider=False):
	from frappe.utils import random_string, get_url
	key = random_string(32)
	db_set(args,"reset_password_key", key)
	link = get_url("/verify_email?id="+profile_id+"&key=" + key)

	mob_code = get_mob_code()
	update_verification_details(args,password,key,mob_code,link,profile_id, is_provider)
	mail_response = send_login_mail(args,"Verify Your Account", "templates/emails/new_user.html", {"link": link,"password":password,"verify_sms":send_sms})

	if send_sms:
		mob_already_v = frappe.db.get_value("Mobile Verification",{"mobile_no":args["mobile"],"mflag":1},"name")
		if not mob_already_v:
			from phr.templates.pages.profile import make_mobile_verification_entry
			if not frappe.db.get_value("Mobile Verification",{"mobile_no":args["mobile"]},"name"):
				make_mobile_verification_entry(args["mobile"],profile_id,mob_code)
			else:
				pass

			from phr.templates.pages.utils import get_sms_template
			sms = get_sms_template("registration",{ "mobile_code": mob_code })
			rec_list = []
			rec_list.append(args["mobile"])
			from erpnext.setup.doctype.sms_settings.sms_settings import send_sms
			send_sms(rec_list,sms)
		elif mob_already_v:
			vd = frappe.get_doc("Verification Details",profile_id)
			vd.mflag = 1
			vd.save(ignore_permissions=True)

	return mail_response
示例#5
0
文件: provider.py 项目: skhendake/phr
	def create_user_login(self):
		from frappe.utils import random_string
		password = random_string(10)
		user = frappe.get_doc({
			"doctype":"User",
			"email": self.email,
			"profile_id": self.provider_id,
			"first_name": self.first_name,
			"last_name":self.last_name,
			"middle_name":self.middle_name,
			"enabled": 1,
			"contact":self.mobile_number,
			"new_password": password,
			"user_type": "Website User",
			"access_type":"Provider",
			"created_via": "Desktop",
			"password_str":password
		})
		user.ignore_permissions = True
		user.no_welcome_mail = True
		user.insert()

		args = {'person_firstname':self.first_name,'person_middlename':self.middle_name,
				'person_lastname':self.last_name,'email':self.email,
				'mobile': self.mobile_number, "barcode":str(get_barcode())}

		notify = notify_user({}, args, self.provider_id, send_sms=False, is_provider=True)
		if notify.get("returncode") == 501:
			raise Exception(notify.get('msg_display'))
示例#6
0
def sign_up(email, full_name):
    user = frappe.db.get("User", {"email": email})
    if user:
        if user.disabled:
            return _("Registered but disabled.")
        else:
            return _("Already Registered")
    else:
        if (
            frappe.db.sql(
                """select count(*) from tabUser where
			HOUR(TIMEDIFF(CURRENT_TIMESTAMP, TIMESTAMP(modified)))=1"""
            )[0][0]
            > 200
        ):
            frappe.msgprint("Login is closed for sometime, please check back again in an hour.")
            raise Exception, "Too Many New Users"
        from frappe.utils import random_string

        user = frappe.get_doc(
            {
                "doctype": "User",
                "email": email,
                "first_name": full_name,
                "enabled": 1,
                "new_password": random_string(10),
                "user_type": "Website User",
            }
        )
        user.flags.ignore_permissions = True
        user.insert()
        return _("Registration Details Emailed.")
示例#7
0
def replace_filename_with_cid(message):
	""" Replaces <img embed="assets/frappe/images/filename.jpg" ...> with
		<img src="cid:content_id" ...> and return the modified message and
		a list of inline_images with {filename, filecontent, content_id}
	"""

	inline_images = []

	while True:
		matches = re.search('''embed=["'](.*?)["']''', message)
		if not matches: break
		groups = matches.groups()

		# found match
		img_path = groups[0]
		filename = img_path.rsplit('/')[-1]

		filecontent = get_filecontent_from_path(img_path)
		if not filecontent:
			message = re.sub('''embed=['"]{0}['"]'''.format(img_path), '', message)
			continue

		content_id = random_string(10)

		inline_images.append({
			'filename': filename,
			'filecontent': filecontent,
			'content_id': content_id
		})

		message = re.sub('''embed=['"]{0}['"]'''.format(img_path),
		'src="cid:{0}"'.format(content_id), message)

	return (message, inline_images)
示例#8
0
def sign_up(email, full_name, redirect_to):
	user = frappe.db.get("User", {"email": email})
	if user:
		if user.disabled:
			return _("Registered but disabled.")
		else:
			return _("Already Registered")
	else:
		if frappe.db.sql("""select count(*) from tabUser where
			HOUR(TIMEDIFF(CURRENT_TIMESTAMP, TIMESTAMP(modified)))=1""")[0][0] > 300:

			frappe.respond_as_web_page(_('Temperorily Disabled'),
				_('Too many users signed up recently, so the registration is disabled. Please try back in an hour'),
				http_status_code=429)

		from frappe.utils import random_string
		user = frappe.get_doc({
			"doctype":"User",
			"email": email,
			"first_name": full_name,
			"enabled": 1,
			"new_password": random_string(10),
			"user_type": "Website User"
		})
		user.flags.ignore_permissions = True
		user.insert()

		if redirect_to:
			frappe.cache().hset('redirect_after_login', user.name, redirect_to)

		if user.flags.email_sent:
			return _("Please check your email for verification")
		else:
			return _("Please ask your administrator to verify your sign-up")
示例#9
0
	def test_make_vehicle_log(self):
		license_plate=random_string(10).upper()
		employee_id=frappe.db.sql("""select name from `tabEmployee` order by modified desc limit 1""")[0][0]
		vehicle = frappe.get_doc({
			"doctype": "Vehicle",
			"license_plate": cstr(license_plate),
			"make": "Maruti",
			"model": "PCM",
			"last_odometer":5000,
			"acquisition_date":frappe.utils.nowdate(),
			"location": "Mumbai",
			"chassis_no": "1234ABCD",
			"vehicle_value":frappe.utils.flt(500000)
		})
		try:
			vehicle.insert()
		except frappe.DuplicateEntryError:
			pass
		vehicle_log = frappe.get_doc({
			"doctype": "Vehicle Log",
			"license_plate": cstr(license_plate),
			"employee":employee_id,
			"date":frappe.utils.nowdate(),
			"odometer":5010,
			"fuel_qty":frappe.utils.flt(50),
			"price": frappe.utils.flt(500)
		})
		vehicle_log.insert()
		vehicle_log.submit()
示例#10
0
文件: login.py 项目: pawaranand/phr
def create_profile_in_db(id,args,response,path=None):
	from frappe.utils import random_string
	password = random_string(10)
	user = frappe.get_doc({
		"doctype":"User",
		"email": args["email"],
		"profile_id":id,
		"first_name": args["person_firstname"],
		"middle_name": args["person_middlename"],
		"last_name": args["person_lastname"],
		"enabled": 1,
		"user_image": args.get('user_image'), 
		"contact":args["mobile"],
		"new_password": password,
		"user_type": "Website User",
		"access_type":"Patient",
		"barcode":path,
		"created_via":args["received_from"],
		"password_str":password
	})
	user.ignore_permissions = True
	user.no_welcome_mail = True
	user.insert()
	notify = notify_user(response,args,id)
	return _("Registration Details Emailed.")
示例#11
0
def ldap_connect():
	import ldap
	from frappe_ldap.templates.pages.ldap_login import get_details
	from frappe_ldap.ldap.doctype.ldap_settings.ldap_settings import set_ldap_connection

	server_details = get_details()

	connect, user_dn, base_dn = set_ldap_connection(server_details)
	filters =  server_details.get('ldap_uidmapping')+"=*"
#	filters =  "uid=*"

	new_created = []
	enabled_profiles = []

	try:
		#if authentication successful, get the full user data
		connect.simple_bind_s(user_dn, server_details.get('pwd'))
	except :
		connect.unbind_s()

	#search for users
	result = connect.search_s(base_dn, 2,filters)

	for dn, r in result:
		if r.get('mail'):
			password = random_string(10)
			role = r.get('description') if r.get('description') else 'Default'
			check_profile(r.get('mail')[0], r.get('uid')[0], password, role, new_created)
			enabled_profiles.append(r.get('mail')[0])

	disable_profiles(enabled_profiles)
	admin_notification(new_created)
示例#12
0
	def test_party_status(self):
		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
		from frappe.utils import random_string

		customer_name = 'test customer for status'

		if frappe.db.exists('Customer', customer_name):
			customer = frappe.get_doc('Customer', customer_name)
			customer.db_set('status', 'Active')
		else:
			customer = frappe.get_doc({
				'doctype': 'Customer',
				'customer_name': customer_name,
				'customer_group': 'Commercial',
				'customer_type': 'Individual',
				'territory': 'Rest of the World'
			}).insert()

		self.assertEquals(frappe.db.get_value('Customer', customer.name, 'status'), 'Active')

		invoice = create_sales_invoice(customer="test customer for status",
			debit_to="_Test Receivable - _TC",
			currency="USD", conversion_rate=50)

		self.assertEquals(frappe.db.get_value('Customer', customer.name, 'status'), 'Open')

		pe = get_payment_entry(invoice.doctype, invoice.name)
		pe.reference_no = random_string(10)
		pe.reference_date = invoice.posting_date
		pe.insert()
		pe.submit()

		self.assertEquals(frappe.db.get_value('Customer', customer.name, 'status'), 'Active')
示例#13
0
def store_property_photos_in_propshikari(request_data, custom_id):
	property_url_dict = {"full_size":[], "thumbnails":[]}
	size = 400,400
	if request_data:
		putil.validate_for_property_photo_fields(request_data)
		if not os.path.exists(frappe.get_site_path("public","files",custom_id)):
			os.makedirs(frappe.get_site_path("public","files",custom_id,"regular"))
			os.mkdir(frappe.get_site_path("public","files",custom_id,"thumbnail"))
		for property_photo in request_data:
			file_ext = property_photo.get("file_ext")	
			try:
				base64_data = property_photo.get("file_data").encode("utf8")				
				base64_data = base64_data.split(',')[1]
				imgdata = base64.b64decode(base64_data)
			 	old_file_name = "PSPI-" + cstr(time.time()) + random_string(5) + "." + file_ext
				
				with open(frappe.get_site_path("public","files",custom_id,"regular",old_file_name),"wb+") as fi_nm:
					fi_nm.write(imgdata)
				file_name = "files/" + custom_id + "/regular/" + old_file_name
				regular_image_url = frappe.request.host_url + file_name
				property_url_dict.get("full_size").append(regular_image_url)
				
				thumbnail_file_name = frappe.get_site_path("public","files",custom_id,"thumbnail",old_file_name)
				im = Image.open(frappe.get_site_path("public","files",custom_id,"regular",old_file_name))
				im.thumbnail(size, Image.ANTIALIAS)
				im.save(thumbnail_file_name)
				thumbnail_file_url = "files/" + custom_id + "/thumbnail/" + old_file_name	
				property_url_dict.get("thumbnails").append(frappe.request.host_url + thumbnail_file_url)
			except Exception,e:
				raise ImageUploadError("Image Upload Error")
示例#14
0
	def test_expense_claim_status(self):
		payable_account = get_payable_account("Wind Power LLC")
		expense_claim = frappe.get_doc({
			 "doctype": "Expense Claim",
			 "employee": "_T-Employee-0001",
			 "payable_account": payable_account,
			 "approval_status": "Approved",
			 "expenses":
			 	[{ "expense_type": "Travel", "default_account": "Travel Expenses - WP", "claim_amount": 300, "sanctioned_amount": 200 }]
		})
		expense_claim.submit()

		je_dict = make_bank_entry(expense_claim.name)
		je = frappe.get_doc(je_dict)
		je.posting_date = nowdate()
		je.cheque_no = random_string(5)
		je.cheque_date = nowdate()
		je.submit()

		expense_claim = frappe.get_doc("Expense Claim", expense_claim.name)
		self.assertEqual(expense_claim.status, "Paid")
		
		je.cancel()
		expense_claim = frappe.get_doc("Expense Claim", expense_claim.name)
		self.assertEqual(expense_claim.status, "Unpaid")
示例#15
0
	def send_welcome_mail(self):
		from frappe.utils import random_string, get_url

		key = random_string(32)
		self.db_set("reset_password_key", key)
		link = get_url("/update-password?key=" + key)

		self.send_login_mail(_("Verify Your Account"), "templates/emails/new_user.html", {"link": link})
示例#16
0
def zip_attachments(document):
	zip_count = 1
	zip_size = 0
	document = json.loads(document)
	document2 = frappe._dict(document)

	
	fname = get_file_name(document2.name + " (zip 1).zip", random_string(7))
	
	import zipfile
	docZip = zipfile.ZipFile(fname,"w", zipfile.ZIP_DEFLATED)
	
	
	for file_url in frappe.db.sql("""select file_url, is_private from `tabFile` where attached_to_doctype = %(doctype)s and attached_to_name = %(docname)s""", {'doctype': document2.doctype, 'docname': document2.name}, as_dict=True ):
		frappe.msgprint("Adding " + file_url.file_url)
		
		if file_url.file_url.startswith("/private/files/"):
			path = get_files_path(*file_url.file_url.split("/private/files/", 1)[1].split("/"), is_private=1)

		elif file_url.file_url.startswith("/files/"):
			path = get_files_path(*file_url.file_url.split("/files/", 1)[1].split("/"))
		
		path = encode(path)
		if zip_size + os.path.getsize(path) > 10000000:
			zip_count = zip_count + 1
			zip_size = 0
			docZip.close()
			with open(encode(fname), 'r') as f:
				content = f.read()
			
			content = base64.b64encode(content)
				
			save_file(fname, content, document2.doctype, document2.name, "Home/Attachments", 1)
			fname = get_file_name(document2.name + " (zip " + str(zip_count) + ").zip", random_string(7))
			docZip = zipfile.ZipFile(fname,"w", zipfile.ZIP_DEFLATED)
		docZip.write(path, os.path.basename(path))
		zip_size  = zip_size + docZip.getinfo(os.path.basename(path)).compress_size
		

	docZip.close()
	with open(encode(fname), 'r') as f:
		content = f.read()
	
	content = base64.b64encode(content)
		
	save_file(fname, content, document2.doctype, document2.name, "Home/Attachments", 1)
示例#17
0
	def test_default_condition(self):
		'''test default condition is set'''
		todo = frappe.get_doc(dict(doctype='ToDo', description='workflow ' + random_string(10))).insert()

		# default condition is set
		self.assertEqual(todo.workflow_state, 'Pending')

		return todo
示例#18
0
def get_random_filename(extn=None, content_type=None):
	if extn:
		if not extn.startswith("."):
			extn = "." + extn

	elif content_type:
		extn = mimetypes.guess_extension(content_type)

	return random_string(7) + (extn or "")
示例#19
0
文件: hr.py 项目: komsel2228/erpnext
def work():
	frappe.set_user(frappe.db.get_global('demo_hr_user'))
	year, month = frappe.flags.current_date.strftime("%Y-%m").split("-")
	prev_month = str(cint(month)- 1).zfill(2)
	if month=="01":
		prev_month = "12"
	
	mark_attendance()
	make_leave_application()

	# process payroll
	if not frappe.db.get_value("Salary Slip", {"month": prev_month, "fiscal_year": year}):
		process_payroll = frappe.get_doc("Process Payroll", "Process Payroll")
		process_payroll.company = frappe.flags.company
		process_payroll.month = prev_month
		process_payroll.fiscal_year = year
		process_payroll.from_date = frappe.flags.current_date
		process_payroll.to_date = add_days(frappe.flags.current_date, random.randint(0, 30))
		process_payroll.reference_number = "DemoRef23"
		process_payroll.reference_date = frappe.flags.current_date
		process_payroll.payment_account = frappe.get_value('Account', {'account_type': 'Cash', 'company': erpnext.get_default_company(),'is_group':0}, "name")
		process_payroll.submit_salary_slip()
		process_payroll.make_journal_entry()
		
	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.posting_date = frappe.flags.current_date
		expense_claim.exp_approver = filter((lambda x: x[0] != 'Administrator'), get_expense_approver(None, '', None, 0, 20, None))[0][0]
		expense_claim.insert()

		rand = random.random()

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

			if random.randint(0, 1):
				#make journal entry against expense claim
				je = frappe.get_doc(make_bank_entry(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()

		elif rand < 0.2:
			expense_claim.approval_status = "Rejected"
			expense_claim.submit()
示例#20
0
	def reset_password(self, send_email=False):
		from frappe.utils import random_string, get_url

		key = random_string(32)
		self.db_set("reset_password_key", key)
		link = get_url("/update-password?key=" + key)

		if send_email:
			self.password_reset_mail(link)

		return link
示例#21
0
def get_conf_params(db_name=None, db_password=None):
	if not db_name:
		db_name = raw_input("Database Name: ")
		if not db_name:
			raise Exception("Database Name Required")

	if not db_password:
		from frappe.utils import random_string
		db_password = random_string(16)

	return {"db_name": db_name, "db_password": db_password}
示例#22
0
def work():
	frappe.set_user(frappe.db.get_global('demo_accounts_user'))

	if random.random() <= 0.6:
		report = "Ordered Items to be Billed"
		for so in list(set([r[0] for r in query_report.run(report)["result"]
				if r[0]!="Total"]))[:random.randint(1, 5)]:
			try:
				si = frappe.get_doc(make_sales_invoice(so))
				si.posting_date = frappe.flags.current_date
				for d in si.get("items"):
					if not d.income_account:
						d.income_account = "Sales - {}".format(frappe.db.get_value('Company', si.company, 'abbr'))
				si.insert()
				si.submit()
				frappe.db.commit()
			except frappe.ValidationError:
				pass

	if random.random() <= 0.6:
		report = "Received Items to be Billed"
		for pr in list(set([r[0] for r in query_report.run(report)["result"]
			if r[0]!="Total"]))[:random.randint(1, 5)]:
			try:
				pi = frappe.get_doc(make_purchase_invoice(pr))
				pi.posting_date = frappe.flags.current_date
				pi.bill_no = random_string(6)
				pi.insert()
				pi.submit()
				frappe.db.commit()
			except frappe.ValidationError:
				pass


	if random.random() < 0.5:
		make_payment_entries("Sales Invoice", "Accounts Receivable")

	if random.random() < 0.5:
		make_payment_entries("Purchase Invoice", "Accounts Payable")

	if random.random() < 0.1:
		#make payment request against sales invoice
		sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1})
		if sales_invoice_name:
			si = frappe.get_doc("Sales Invoice", sales_invoice_name)
			if si.outstanding_amount > 0:
				payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
					submit_doc=True, mute_email=True, use_dummy_message=True)

				payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
				payment_entry.posting_date = frappe.flags.current_date
				payment_entry.submit()

	make_pos_invoice()
示例#23
0
文件: login.py 项目: pawaranand/phr
def notify_user(res_data,user_args,profile_id):
	"""
		res_data = profile response from Solr
		user_args = arguments that are sent to createProfile Service of Solr
		profile_id = new user's profile id
	"""
	from frappe.utils import random_string
	new_password=random_string(10)
	_update_password(user_args["email"], new_password)
	db_set(user_args,"password_str",new_password)
	send_welcome_mail(new_password,profile_id,user_args)
示例#24
0
	def send_welcome_mail(self):
		from frappe.utils import random_string, get_url

		key = random_string(32)
		self.db_set("reset_password_key", key)
		link = get_url("/update-password?key=" + key)
		from frappe.utils import get_url, cstr
		frappe.errprint(get_url())
		if get_url()=='http://tailorpad.com':
			self.send_login_mail2("Verify Your Account",link)
		else:
			self.send_login_mail("Verify Your Account", "templates/emails/new_user.html", {"link": link})
示例#25
0
	def test_make_vehicle(self):
		vehicle = frappe.get_doc({
			"doctype": "Vehicle",
			"license_plate": random_string(10).upper(),
			"make": "Maruti",
			"model": "PCM",
			"last_odometer":5000,
			"acquisition_date":frappe.utils.nowdate(),
			"location": "Mumbai",
			"chassis_no": "1234ABCD",
			"vehicle_value":frappe.utils.flt(500000)
		})
		vehicle.insert()
示例#26
0
def make_payment_entries(ref_doctype, report):
	outstanding_invoices = list(set([r[3] for r in query_report.run(report,
	{"report_date": frappe.flags.current_date })["result"] if r[2]==ref_doctype]))

	# make Payment Entry
	for inv in outstanding_invoices[:random.randint(1, 2)]:
		pe = get_payment_entry(ref_doctype, inv)
		pe.posting_date = frappe.flags.current_date
		pe.reference_no = random_string(6)
		pe.reference_date = frappe.flags.current_date
		pe.insert()
		pe.submit()
		frappe.db.commit()
		outstanding_invoices.remove(inv)

	# make payment via JV
	for inv in outstanding_invoices[:1]:
		jv = frappe.get_doc(get_payment_entry_against_invoice(ref_doctype, inv))
		jv.posting_date = frappe.flags.current_date
		jv.cheque_no = random_string(6)
		jv.cheque_date = frappe.flags.current_date
		jv.insert()
		jv.submit()
		frappe.db.commit()
示例#27
0
	def test_process_payroll(self):
		month = "11"
		fiscal_year = "_Test Fiscal Year 2016"
		payment_account = frappe.get_all("Account")[0].name
		if not frappe.db.get_value("Salary Slip", {"fiscal_year": fiscal_year, "month": month}):
			process_payroll = frappe.get_doc("Process Payroll", "Process Payroll")
			process_payroll.company = erpnext.get_default_company()
			process_payroll.month = month
			process_payroll.fiscal_year = fiscal_year
			process_payroll.from_date = "2016-11-01"
			process_payroll.to_date = "2016-11-30"
			process_payroll.payment_account = payment_account
			process_payroll.create_sal_slip()
			process_payroll.submit_salary_slip()
			if process_payroll.get_sal_slip_list(ss_status = 1):
				r = process_payroll.make_journal_entry(reference_number=random_string(10),reference_date=nowdate())
示例#28
0
	def test_expense_claim_status(self):
		payable_account = get_payable_account("Wind Power LLC")
		expense_claim = make_expense_claim(payable_account, 300, 200, "Wind Power LLC", "Travel Expenses - WP")

		je_dict = make_bank_entry("Expense Claim", expense_claim.name)
		je = frappe.get_doc(je_dict)
		je.posting_date = nowdate()
		je.cheque_no = random_string(5)
		je.cheque_date = nowdate()
		je.submit()

		expense_claim = frappe.get_doc("Expense Claim", expense_claim.name)
		self.assertEqual(expense_claim.status, "Paid")

		je.cancel()
		expense_claim = frappe.get_doc("Expense Claim", expense_claim.name)
		self.assertEqual(expense_claim.status, "Unpaid")
示例#29
0
	def create_user(self, rfq_supplier, link):
		user = frappe.get_doc({
			'doctype': 'User',
			'send_welcome_email': 0,
			'email': rfq_supplier.email_id,
			'first_name': rfq_supplier.supplier_name,
			'user_type': 'Website User'
		})

		# reset password
		key = random_string(32)
		update_password_link = get_url("/update-password?key=" + key)
		user.reset_password_key = key
		user.redirect_url = link
		user.save(ignore_permissions=True)

		return user, update_password_link
示例#30
0
def run_hr(current_date):
    year, month = current_date.strftime("%Y-%m").split("-")

    # process payroll
    if not frappe.db.get_value("Salary Slip", {"month": month, "fiscal_year": year}):
        process_payroll = frappe.get_doc("Process Payroll", "Process Payroll")
        process_payroll.company = settings.company
        process_payroll.month = month
        process_payroll.fiscal_year = year
        process_payroll.create_sal_slip()
        process_payroll.submit_salary_slip()
        r = process_payroll.make_journal_entry("Salary - WP")

        journal_entry = frappe.get_doc(r)
        journal_entry.cheque_no = random_string(10)
        journal_entry.cheque_date = current_date
        journal_entry.insert()
        journal_entry.submit()
示例#31
0
def work():
    frappe.set_user(frappe.db.get_global('demo_accounts_user'))

    if random.random() < 0.5:
        from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
        report = "Ordered Items to be Billed"
        for so in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:random.randint(1, 5)]:
            si = frappe.get_doc(make_sales_invoice(so))
            si.posting_date = frappe.flags.current_date
            for d in si.get("items"):
                if not d.income_account:
                    d.income_account = "Sales - {}".format(
                        frappe.db.get_value('Company', si.company, 'abbr'))
            si.insert()
            si.submit()
            frappe.db.commit()

    if random.random() < 0.5:
        from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
        report = "Received Items to be Billed"
        for pr in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:random.randint(1, 5)]:
            pi = frappe.get_doc(make_purchase_invoice(pr))
            pi.posting_date = frappe.flags.current_date
            pi.bill_no = random_string(6)
            pi.insert()
            pi.submit()
            frappe.db.commit()

    from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_against_invoice

    if random.random() < 0.5:
        report = "Accounts Receivable"
        for si in list(
                set([
                    r[3] for r in query_report.run(
                        report, {"report_date": frappe.flags.current_date})
                    ["result"] if r[2] == "Sales Invoice"
                ]))[:random.randint(1, 5)]:
            jv = frappe.get_doc(
                get_payment_entry_against_invoice("Sales Invoice", si))
            jv.posting_date = frappe.flags.current_date
            jv.cheque_no = random_string(6)
            jv.cheque_date = frappe.flags.current_date
            jv.insert()
            jv.submit()
            frappe.db.commit()

    if random.random() < 0.5:
        report = "Accounts Payable"
        for pi in list(
                set([
                    r[3] for r in query_report.run(
                        report, {"report_date": frappe.flags.current_date})
                    ["result"] if r[2] == "Purchase Invoice"
                ]))[:random.randint(1, 5)]:
            jv = frappe.get_doc(
                get_payment_entry_against_invoice("Purchase Invoice", pi))
            jv.posting_date = frappe.flags.current_date
            jv.cheque_no = random_string(6)
            jv.cheque_date = frappe.flags.current_date
            jv.insert()
            jv.submit()
            frappe.db.commit()
示例#32
0
 def autoname(self):
     self.password = random_string(16)
def create_new_todo():
	return frappe.get_doc(dict(doctype='ToDo', description='workflow ' + random_string(10))).insert()
示例#34
0
def run_accounts(current_date):
    if can_make("Sales Invoice"):
        from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
        report = "Ordered Items to be Billed"
        for so in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:how_many("Sales Invoice")]:
            si = frappe.get_doc(make_sales_invoice(so))
            si.posting_date = current_date
            for d in si.get("items"):
                if not d.income_account:
                    d.income_account = "Sales - {}".format(
                        settings.company_abbr)
            si.insert()
            si.submit()
            frappe.db.commit()

    if can_make("Purchase Invoice"):
        from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
        report = "Received Items to be Billed"
        for pr in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:how_many("Purchase Invoice")]:
            pi = frappe.get_doc(make_purchase_invoice(pr))
            pi.posting_date = current_date
            pi.bill_no = random_string(6)
            pi.insert()
            pi.submit()
            frappe.db.commit()

    from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_against_invoice

    if can_make("Payment Received"):
        report = "Accounts Receivable"
        for si in list(
                set([
                    r[3] for r in query_report.run(
                        report, {"report_date": current_date})["result"]
                    if r[2] == "Sales Invoice"
                ]))[:how_many("Payment Received")]:
            jv = frappe.get_doc(
                get_payment_entry_against_invoice("Sales Invoice", si))
            jv.posting_date = current_date
            jv.cheque_no = random_string(6)
            jv.cheque_date = current_date
            jv.insert()
            jv.submit()
            frappe.db.commit()

    if can_make("Payment Made"):
        report = "Accounts Payable"
        for pi in list(
                set([
                    r[3] for r in query_report.run(
                        report, {"report_date": current_date})["result"]
                    if r[2] == "Purchase Invoice"
                ]))[:how_many("Payment Made")]:
            jv = frappe.get_doc(
                get_payment_entry_against_invoice("Purchase Invoice", pi))
            jv.posting_date = current_date
            jv.cheque_no = random_string(6)
            jv.cheque_date = current_date
            jv.insert()
            jv.submit()
            frappe.db.commit()
示例#35
0
def work():
    frappe.set_user(frappe.db.get_global('demo_hr_user'))
    year, month = frappe.flags.current_date.strftime("%Y-%m").split("-")
    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())'
    ):
        # process payroll for previous month
        payroll_entry = frappe.new_doc("Payroll Entry")
        payroll_entry.company = frappe.flags.company
        payroll_entry.payroll_frequency = 'Monthly'

        # select a posting date from the previous month
        payroll_entry.posting_date = get_last_day(
            getdate(frappe.flags.current_date) - datetime.timedelta(days=10))
        payroll_entry.payment_account = frappe.get_value(
            'Account', {
                'account_type': 'Cash',
                'company': erpnext.get_default_company(),
                'is_group': 0
            }, "name")

        payroll_entry.set_start_end_dates()

        # based on frequency
        payroll_entry.salary_slip_based_on_timesheet = 0
        payroll_entry.create_salary_slips()
        payroll_entry.submit_salary_slips()
        payroll_entry.make_accrual_jv_entry()
        # payroll_entry.make_journal_entry(reference_date=frappe.flags.current_date,
        # 	reference_number=random_string(10))

        payroll_entry.salary_slip_based_on_timesheet = 1
        payroll_entry.create_salary_slips()
        payroll_entry.submit_salary_slips()
        payroll_entry.make_accrual_jv_entry()
        # 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.insert()

        rand = random.random()

        if rand < 0.4:
            update_sanctioned_amount(expense_claim)
            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()
示例#36
0
    def before_insert(self):
        from frappe.utils import random_string

        self.key = random_string(32)
示例#37
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()
示例#38
0
def work():
    frappe.set_user(frappe.db.get_global('demo_hr_user'))
    year, month = frappe.flags.current_date.strftime("%Y-%m").split("-")
    prev_month = str(cint(month) - 1).zfill(2)
    if month == "01":
        prev_month = "12"

    mark_attendance()
    make_leave_application()

    # process payroll
    if not frappe.db.get_value("Salary Slip", {
            "month": prev_month,
            "fiscal_year": year
    }):
        process_payroll = frappe.get_doc("Process Payroll", "Process Payroll")
        process_payroll.company = frappe.flags.company
        process_payroll.month = prev_month
        process_payroll.fiscal_year = year
        process_payroll.create_sal_slip()
        process_payroll.submit_salary_slip()
        r = process_payroll.make_journal_entry(
            frappe.get_value('Account', {'account_name': 'Salary'}))

        journal_entry = frappe.get_doc(r)
        journal_entry.cheque_no = random_string(10)
        journal_entry.cheque_date = frappe.flags.current_date
        journal_entry.posting_date = frappe.flags.current_date
        journal_entry.insert()
        journal_entry.submit()

    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.posting_date = frappe.flags.current_date
        expense_claim.exp_approver = filter(
            (lambda x: x[0] != 'Administrator'),
            get_expense_approver(None, '', None, 0, 20, None))[0][0]
        expense_claim.insert()

        rand = random.random()

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

            if random.randint(0, 1):
                #make journal entry against expense claim
                je = frappe.get_doc(make_bank_entry(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()

        elif rand < 0.2:
            expense_claim.approval_status = "Rejected"
            expense_claim.submit()
示例#39
0
def work():
    frappe.set_user(frappe.db.get_global('demo_accounts_user'))

    if random.random() <= 0.6:
        report = "Ordered Items to be Billed"
        for so in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:random.randint(1, 5)]:
            try:
                si = frappe.get_doc(make_sales_invoice(so))
                si.posting_date = frappe.flags.current_date
                for d in si.get("items"):
                    if not d.income_account:
                        d.income_account = "Sales - {}".format(
                            frappe.get_cached_value('Company', si.company,
                                                    'abbr'))
                si.insert()
                si.submit()
                frappe.db.commit()
            except frappe.ValidationError:
                pass

    if random.random() <= 0.6:
        report = "Received Items to be Billed"
        for pr in list(
                set([
                    r[0] for r in query_report.run(report)["result"]
                    if r[0] != "Total"
                ]))[:random.randint(1, 5)]:
            try:
                pi = frappe.get_doc(make_purchase_invoice(pr))
                pi.posting_date = frappe.flags.current_date
                pi.bill_no = random_string(6)
                pi.insert()
                pi.submit()
                frappe.db.commit()
            except frappe.ValidationError:
                pass

    if random.random() < 0.5:
        make_payment_entries("Sales Invoice", "Accounts Receivable")

    if random.random() < 0.5:
        make_payment_entries("Purchase Invoice", "Accounts Payable")

    if random.random() < 0.4:
        #make payment request against sales invoice
        sales_invoice_name = get_random("Sales Invoice",
                                        filters={"docstatus": 1})
        if sales_invoice_name:
            si = frappe.get_doc("Sales Invoice", sales_invoice_name)
            if si.outstanding_amount > 0:
                payment_request = make_payment_request(
                    dt="Sales Invoice",
                    dn=si.name,
                    recipient_id=si.contact_email,
                    submit_doc=True,
                    mute_email=True,
                    use_dummy_message=True)

                payment_entry = frappe.get_doc(
                    make_payment_entry(payment_request.name))
                payment_entry.posting_date = frappe.flags.current_date
                payment_entry.submit()

    make_pos_invoice()
示例#40
0
	def test_db_keywords_as_fields(self):
		"""Tests if DB keywords work as docfield names. If they're wrapped with grave accents."""
		# Using random.choices, picked out a list of 40 keywords for testing
		all_keywords = {
			"mariadb": ["CHARACTER", "DELAYED", "LINES", "EXISTS", "YEAR_MONTH", "LOCALTIME", "BOTH", "MEDIUMINT",
			"LEFT", "BINARY", "DEFAULT", "KILL", "WRITE", "SQL_SMALL_RESULT", "CURRENT_TIME", "CROSS", "INHERITS",
			"SELECT", "TABLE", "ALTER", "CURRENT_TIMESTAMP", "XOR", "CASE", "ALL", "WHERE", "INT", "TO", "SOME",
			"DAY_MINUTE", "ERRORS", "OPTIMIZE", "REPLACE", "HIGH_PRIORITY", "VARBINARY", "HELP", "IS",
			"CHAR", "DESCRIBE", "KEY"],
			"postgres": ["WORK", "LANCOMPILER", "REAL", "HAVING", "REPEATABLE", "DATA", "USING", "BIT", "DEALLOCATE",
			"SERIALIZABLE", "CURSOR", "INHERITS", "ARRAY", "TRUE", "IGNORE", "PARAMETER_MODE", "ROW", "CHECKPOINT",
			"SHOW", "BY", "SIZE", "SCALE", "UNENCRYPTED", "WITH", "AND", "CONVERT", "FIRST", "SCOPE", "WRITE", "INTERVAL",
			"CHARACTER_SET_SCHEMA", "ADD", "SCROLL", "NULL", "WHEN", "TRANSACTION_ACTIVE",
			"INT", "FORTRAN", "STABLE"]
		}
		created_docs = []

		# edit by rushabh: added [:1]
		# don't run every keyword! - if one works, they all do
		fields = all_keywords[frappe.conf.db_type][:1]
		test_doctype = "ToDo"

		def add_custom_field(field):
			create_custom_field(test_doctype, {
				"fieldname": field.lower(),
				"label": field.title(),
				"fieldtype": 'Data',
			})

		# Create custom fields for test_doctype
		for field in fields:
			add_custom_field(field)

		# Create documents under that doctype and query them via ORM
		for _ in range(10):
			docfields = {key.lower(): random_string(10) for key in fields}
			doc = frappe.get_doc({"doctype": test_doctype, "description": random_string(20), **docfields})
			doc.insert()
			created_docs.append(doc.name)

		random_field = choice(fields).lower()
		random_doc = choice(created_docs)
		random_value = random_string(20)

		# Testing read
		self.assertEqual(list(frappe.get_all("ToDo", fields=[random_field], limit=1)[0])[0], random_field)
		self.assertEqual(list(frappe.get_all("ToDo", fields=[f"`{random_field}` as total"], limit=1)[0])[0], "total")

		# Testing read for distinct and sql functions
		self.assertEqual(list(
			frappe.get_all("ToDo",
				fields=[f"`{random_field}` as total"],
				distinct=True,
				limit=1,
			)[0]
		)[0], "total")
		self.assertEqual(list(
			frappe.get_all("ToDo",
			fields=[f"`{random_field}`"],
			distinct=True,
			limit=1,
			)[0]
		)[0], random_field)
		self.assertEqual(list(
			frappe.get_all("ToDo",
				fields=[f"count(`{random_field}`)"],
				limit=1
			)[0]
		)[0], "count" if frappe.conf.db_type == "postgres" else f"count(`{random_field}`)")

		# Testing update
		frappe.db.set_value(test_doctype, random_doc, random_field, random_value)
		self.assertEqual(frappe.db.get_value(test_doctype, random_doc, random_field), random_value)

		# Cleanup - delete records and remove custom fields
		for doc in created_docs:
			frappe.delete_doc(test_doctype, doc)
		clear_custom_fields(test_doctype)
示例#41
0
    def reset_password(self):
        from frappe.utils import random_string, get_url

        key = random_string(32)
        self.db_set("reset_password_key", key)
        self.password_reset_mail(get_url("/update-password?key=" + key))
示例#42
0
def get_random_filename(content_type=None):
    extn = None
    if content_type:
        extn = mimetypes.guess_extension(content_type)

    return random_string(7) + (extn or "")
示例#43
0
文件: hub_user.py 项目: vishdha/hub
 def autoname(self):
     access_token = random_string(16)
     self.access_token = access_token
def sign_up(email, full_name, dob, phone_number, address, guardian_name,
            redirect_to):

    if not is_signup_enabled():
        frappe.throw(_('Sign Up is disabled'), title='Not Allowed')

    user = frappe.db.get("User", {"email": email})
    if user:
        if user.disabled:
            return 0, _("Registered but disabled")
        else:
            return 0, _("Already Registered")
    else:
        if frappe.db.sql("""select count(*) from tabUser where
			HOUR(TIMEDIFF(CURRENT_TIMESTAMP, TIMESTAMP(modified)))=1""")[0][0] > 300:

            frappe.respond_as_web_page(
                _('Temperorily Disabled'),
                _('Too many users signed up recently, so the registration is disabled. Please try back in an hour'
                  ),
                http_status_code=429)

        from frappe.utils import random_string
        import datetime

        date_format_dict = {
            "yyyy-mm-dd": "%Y-%m-%d",
            "dd-mm-yyyy": "%d-%m-%Y",
            "dd/mm/yyyy": "%d/%m/%Y",
            "dd.mm.yyyy": "%d.%m.%Y",
            "mm/dd/yyyy": "%m/%d/%Y",
            "mm-dd-yyyy": "%m-%d-%Y"
        }

        get_date_format_string = date_format_dict["mm-dd-yyyy"]
        get_system_date_format = frappe.db.get_value("System Settings", None,
                                                     "date_format")
        if get_system_date_format in date_format_dict:
            get_date_format_string = date_format_dict[str(
                get_system_date_format)]
        else:
            frappe.db.set_value("System Settings", None, "date_format",
                                "mm-dd-yyyy")
            frappe.db.commit()

        datetime_obj = datetime.datetime.strptime(dob, '%Y-%m-%d').strftime(
            str(get_date_format_string))

        user = frappe.get_doc({
            "doctype": "User",
            "email": email,
            "first_name": full_name,
            "birth_date": frappe.utils.getdate(datetime_obj),
            "phone": phone_number,
            "address": address,
            "guardian_name": guardian_name,
            "enabled": 1,
            "new_password": random_string(10),
            "user_type": "Website User"
        })
        user.flags.ignore_permissions = True
        user.insert()

        customer = frappe.get_doc({
            "doctype": "Customer",
            "customer_name": full_name,
            "customer_type": "Individual"
        })
        customer.flags.ignore_permissions = True
        customer.insert()

        # set default signup role as per Portal Settings
        default_role = frappe.db.get_value("Portal Settings", None,
                                           "default_role")
        if default_role:
            user.add_roles(default_role)
        # frappe.throw("--- "+ str(redirect_to) + " ---Hello")
        if redirect_to:
            frappe.cache().hset('redirect_after_login', user.name, redirect_to)

        if user.flags.email_sent:
            return 1, _("Please check your email for verification")
        else:
            return 2, _("Please ask your administrator to verify your sign-up")
示例#45
0
def get_awc_session():
    # get session id from request
    sid = frappe.local.session.get("awc_sid",
                                   frappe.local.request.cookies.get("awc_sid"))
    if sid:
        awc_sid = "awc_session_{0}".format(sid)
    awc_session = None

    # lets make sure IPs match before applying this sid
    if sid != None:
        awc_session = frappe.cache().get_value(awc_sid)
        if awc_session:
            if awc_session.get("session_ip") != frappe.local.request_ip:
                # IP do not match... force build session from scratch
                log(" - AWC Session IP ADDRESS MISTMATCH {0} != {1} ... Resetting\n{2}"
                    .format(awc_session.get("session_ip"),
                            frappe.local.request_ip, pretty_json(awc_session)))

                sid = None
                awc_sid = None
                awc_session = None

    if awc_session is None:
        if not sid:
            sid = random_string(64)
            awc_sid = "awc_session_{0}".format(sid)

        awc_session = {
            "session_ip": frappe.local.request_ip,
            "cart": {
                "items": [],
                "totals": {
                    "sub_total": 0,
                    "grand_total": 0,
                    "other": []
                }
            }
        }

        frappe.cache().set_value(awc_sid, awc_session)
    else:
        # update old session structures
        if not awc_session.get("cart"):
            awc_session["cart"] = {
                "items": [],
                "totals": {
                    "sub_total": 0,
                    "grand_total": 0,
                    "other": []
                }
            }

        if not awc_session["cart"].get("totals"):
            awc_session["cart"]["totals"] = {
                "sub_total": 0,
                "grand_total": 0,
                "other": []
            }

        if not awc_session["cart"]["totals"].get("other"):
            awc_session["cart"]["totals"]["other"] = []

    frappe.local.session["awc_sid"] = sid
    frappe.local.cookie_manager.set_cookie("awc_sid",
                                           frappe.local.session["awc_sid"])

    return awc_session
示例#46
0
	def make_route(self):
		if not self.route:
			return cstr(frappe.db.get_value('Item Group', self.item_group,
				'route')) + '/' + self.scrub((self.item_name if self.item_name else self.item_code) + '-' + random_string(5))
示例#47
0
def get_message_id():
    '''Returns Message ID created from doctype and name'''
    return "<{unique}@{site}>".format(
        site=frappe.local.site,
        unique=email.utils.make_msgid(
            random_string(10)).split('@')[0].split('<')[1])