Python webnotes.has_permission函数代码示例

def get_value(doctype, fieldname, filters=None, as_dict=True, debug=False):
	if not webnotes.has_permission(doctype):
		webnotes.msgprint("No Permission", raise_exception=True)
		
	if fieldname and fieldname.startswith("["):
		fieldname = json.loads(fieldname)
	return webnotes.conn.get_value(doctype, json.loads(filters), fieldname, as_dict=as_dict, debug=debug)

	def save(self, check_links=1):
		perm_to_check = "write"
		if self.doc.fields.get("__islocal"):
			perm_to_check = "create"
			if not self.doc.owner:
				self.doc.owner = webnotes.session.user
				
		if self.ignore_permissions or webnotes.has_permission(self.doc.doctype, perm_to_check, self.doc):
			self.to_docstatus = 0
			self.prepare_for_save("save")
			if self.doc.fields.get("__islocal"):
				# set name before validate
				self.doc.set_new_name()
				self.run_method('before_insert')
				
			if not self.ignore_validate:
				self.run_method('validate')
			if not self.ignore_mandatory:
				self.check_mandatory()
			self.save_main()
			self.save_children()
			self.run_method('on_update')
		else:
			self.no_permission_to(_(perm_to_check.title()))
		
		return self

def run(report_name, filters=None):
	report = webnotes.doc("Report", report_name)
	
	if filters and isinstance(filters, basestring):
		filters = json.loads(filters)

	if not webnotes.has_permission(report.ref_doctype, "report"):
		webnotes.msgprint(_("Must have report permission to access this report."), 
			raise_exception=True)
	
	if report.report_type=="Query Report":
		if not report.query:
			webnotes.msgprint(_("Must specify a Query to run"), raise_exception=True)
	
	
		if not report.query.lower().startswith("select"):
			webnotes.msgprint(_("Query must be a SELECT"), raise_exception=True)
		
		result = [list(t) for t in webnotes.conn.sql(report.query, filters)]
		columns = [c[0] for c in webnotes.conn.get_description()]
	else:
		method_name = scrub(webnotes.conn.get_value("DocType", report.ref_doctype, "module")) \
			+ ".report." + scrub(report.name) + "." + scrub(report.name) + ".execute"
		columns, result = webnotes.get_method(method_name)(filters or {})
	
	result = get_filtered_data(report.ref_doctype, columns, result)
	
	if cint(report.add_total_row) and result:
		result = add_total_row(result, columns)
	
	return {
		"result": result,
		"columns": columns
	}

def get_events(start, end, filters=None):
	from webnotes.widgets.reportview import build_match_conditions
	if not webnotes.has_permission("Task"):
		webnotes.msgprint(_("No Permission"), raise_exception=1)

	conditions = build_match_conditions("Task")
	conditions and (" and " + conditions) or ""
	
	if filters:
		filters = json.loads(filters)
		for key in filters:
			if filters[key]:
				conditions += " and " + key + ' = "' + filters[key].replace('"', '\"') + '"'
	
	data = webnotes.conn.sql("""select name, exp_start_date, exp_end_date, 
		subject, status, project from `tabTask`
		where ((exp_start_date between '%(start)s' and '%(end)s') \
			or (exp_end_date between '%(start)s' and '%(end)s'))
		%(conditions)s""" % {
			"start": start,
			"end": end,
			"conditions": conditions
		}, as_dict=True, update={"allDay": 0})

	return data

def get_args():
    if not webnotes.form_dict.format:
        webnotes.form_dict.format = standard_format
    if not webnotes.form_dict.doctype or not webnotes.form_dict.name:
        return {
            "body": """<h1>Error</h1>
				<p>Parameters doctype, name and format required</p>
				<pre>%s</pre>"""
            % repr(webnotes.form_dict)
        }

    bean = webnotes.bean(webnotes.form_dict.doctype, webnotes.form_dict.name)
    for ptype in ("read", "print"):
        if not webnotes.has_permission(bean.doc.doctype, ptype, bean.doc):
            return {
                "body": """<h1>Error</h1>
					<p>No {ptype} permission</p>""".format(
                    ptype=ptype
                )
            }

    return {
        "body": get_html(bean.doc, bean.doclist),
        "css": get_print_style(webnotes.form_dict.style),
        "comment": webnotes.session.user,
    }

def upload(select_doctype=None, rows=None):
	from webnotes.utils.datautils import read_csv_content_from_uploaded_file
	from webnotes.modules import scrub
	from webnotes.model.rename_doc import rename_doc

	if not select_doctype:
		select_doctype = webnotes.form_dict.select_doctype
		
	if not webnotes.has_permission(select_doctype, "write"):
		raise webnotes.PermissionError

	if not rows:
		rows = read_csv_content_from_uploaded_file()
	if not rows:
		webnotes.msgprint(_("Please select a valid csv file with data."))
		raise Exception
		
	if len(rows) > 500:
		webnotes.msgprint(_("Max 500 rows only."))
		raise Exception
	
	rename_log = []
	for row in rows:
		# if row has some content
		if len(row) > 1 and row[0] and row[1]:
			try:
				if rename_doc(select_doctype, row[0], row[1]):
					rename_log.append(_("Successful: ") + row[0] + " -> " + row[1])
					webnotes.conn.commit()
				else:
					rename_log.append(_("Ignored: ") + row[0] + " -> " + row[1])
			except Exception, e:
				rename_log.append("<span style='color: RED'>" + \
					_("Failed: ") + row[0] + " -> " + row[1] + "</span>")
				rename_log.append("<span style='margin-left: 20px;'>" + repr(e) + "</span>")

def run(report_name):
	report = webnotes.doc("Report", report_name)

	if not webnotes.has_permission(report.ref_doctype, "report"):
		webnotes.msgprint(_("Must have report permission to access this report."), 
			raise_exception=True)
	
	if report.report_type=="Query Report":
		if not report.query:
			webnotes.msgprint(_("Must specify a Query to run"), raise_exception=True)
	
	
		if not report.query.lower().startswith("select"):
			webnotes.msgprint(_("Query must be a SELECT"), raise_exception=True)
		
		result = [list(t) for t in webnotes.conn.sql(report.query)]
		columns = [c[0] for c in webnotes.conn.get_description()]
	else:
		from webnotes.modules import scrub
		method_name = scrub(webnotes.conn.get_value("DocType", report.ref_doctype, "module")) \
			+ ".report." + scrub(report.name) + "." + scrub(report.name) + ".execute"
		columns, result = webnotes.get_method(method_name)()
	
	return {
		"result": result,
		"columns": columns
	}

def get_mapped_doclist(from_doctype, from_docname, table_maps, target_doclist=[], 
		postprocess=None, ignore_permissions=False):
	if isinstance(target_doclist, basestring):
		target_doclist = json.loads(target_doclist)
	
	source = webnotes.bean(from_doctype, from_docname)

	if not ignore_permissions and not webnotes.has_permission(from_doctype, "read", source.doc):
		webnotes.msgprint("No Permission", raise_exception=webnotes.PermissionError)

	source_meta = webnotes.get_doctype(from_doctype)
	target_meta = webnotes.get_doctype(table_maps[from_doctype]["doctype"])
	
	# main
	if target_doclist:
		if isinstance(target_doclist[0], dict):
			target_doc = webnotes.doc(fielddata=target_doclist[0])
		else:
			target_doc = target_doclist[0]
	else:
		target_doc = webnotes.new_doc(table_maps[from_doctype]["doctype"])
	
	map_doc(source.doc, target_doc, table_maps[source.doc.doctype], source_meta, target_meta)
	if target_doclist:
		target_doclist[0] = target_doc
	else:
		target_doclist = [target_doc]
	
	# children
	for source_d in source.doclist[1:]:
		table_map = table_maps.get(source_d.doctype)
		if table_map:
			if "condition" in table_map:
				if not table_map["condition"](source_d):
					continue
			target_doctype = table_map["doctype"]
			parentfield = target_meta.get({
					"parent": target_doc.doctype, 
					"doctype": "DocField",
					"fieldtype": "Table", 
					"options": target_doctype
				})[0].fieldname
			
			if table_map.get("add_if_empty") and row_exists_in_target(parentfield, target_doclist):
				continue
		
			target_d = webnotes.new_doc(target_doctype, target_doc, parentfield)
			map_doc(source_d, target_d, table_map, source_meta, target_meta, source.doclist[0])
			target_doclist.append(target_d)
	
	target_doclist = webnotes.doclist(target_doclist)
	
	if postprocess:
		new_target_doclist = postprocess(source, target_doclist)
		if new_target_doclist:
			target_doclist = new_target_doclist
	
	return target_doclist

def check_permission_and_not_submitted(doctype, name):
	# permission
	if webnotes.session.user!="Administrator" and not webnotes.has_permission(doctype, "cancel"):
		webnotes.msgprint(_("User not allowed to delete."), raise_exception=True)

	# check if submitted
	if webnotes.conn.get_value(doctype, name, "docstatus") == 1:
		webnotes.msgprint(_("Submitted Record cannot be deleted")+": "+name+"("+doctype+")",
			raise_exception=True)

	def submit(self):
		if webnotes.has_permission(self.doc.doctype, "submit"):
			if self.doc.docstatus != 0:
				webnotes.msgprint("Only draft can be submitted", raise_exception=1)
			self.to_docstatus = 1
			self.save()
			self.run_method('on_submit')
		else:
			webnotes.msgprint("No Permission to Submit", raise_exception=True)

	def save(self, check_links=1):
		if webnotes.has_permission(self.doc.doctype, "write"):
			self.prepare_for_save(check_links)
			self.run_method('validate')
			self.save_main()
			self.save_children()
			self.run_method('on_update')
		else:
			webnotes.msgprint("No Permission to Write", raise_exception=True)

def get_report_doc(report_name):
	bean = webnotes.bean("Report", report_name)
	if not bean.has_read_perm():
		raise webnotes.PermissionError("You don't have access to: {report}".format(report=report_name))
		
	if not webnotes.has_permission(bean.doc.ref_doctype, "report"):
		raise webnotes.PermissionError("You don't have access to get a report on: {doctype}".format(
			doctype=bean.doc.ref_doctype))
		
	return bean.doc

	def cancel(self):
		if webnotes.has_permission(self.doc.doctype, "submit"):
			if self.doc.docstatus != 1:
				webnotes.msgprint("Only submitted can be cancelled", raise_exception=1)
			self.to_docstatus = 2
			self.prepare_for_save(1)
			self.save_main()
			self.save_children()
			self.run_method('on_cancel')
		else:
			webnotes.msgprint("No Permission to Cancel", raise_exception=True)

	def submit(self):
		if self.ignore_permissions or webnotes.has_permission(self.doc.doctype, "submit", self.doc):
			if self.doc.docstatus != 0:
				webnotes.msgprint("Only draft can be submitted", raise_exception=1)
			self.to_docstatus = 1
			self.save()
			self.run_method('on_submit')
		else:
			self.no_permission_to(_("Submit"))
			
		return self

	def save(self, check_links=1):
		if self.ignore_permissions or webnotes.has_permission(self.doc.doctype, "write", self.doc):
			self.prepare_for_save(check_links)
			self.run_method('validate')
			self.save_main()
			self.save_children()
			self.run_method('on_update')
		else:
			self.no_permission_to(_("Write"))
		
		return self