def doc_filter_perm_roles(self, doctype, data, docnames):
		new_data = {}
		added = 0
		for k,v in data.iteritems():
			if isinstance(v, dict):
				if v.get("Doctype name") == doctype or v.get("report") == doctype:
					if docnames and v.get('jasper_report_type') == "List":
						continue
					if frappe.local.session['user'] != "Administrator":
						frappe.flags.mute_messages = True
						to_remove = False
						ptypes = ("read", )
						if not utils.check_frappe_permission("Jasper Reports", k, ptypes=ptypes):
							continue
						for docname in docnames:
							if not utils.check_frappe_permission(doctype, docname, ptypes=ptypes):
								to_remove = True
								break
						frappe.flags.mute_messages = False
						if to_remove == True:
							continue
					new_data[k] = v
					added = added + 1
		new_data['size'] = added
		return new_data
Ejemplo n.º 2
0
	def doc_filter_perm_roles(self, doctype, data, docnames):
		new_data = {}
		added = 0
		for k,v in data.iteritems():
			if isinstance(v, dict):
				if v.get("Doctype name") == doctype or v.get("report") == doctype:
					if docnames and v.get('jasper_report_type') == "List":
						continue
					if frappe.local.session['user'] != "Administrator":
						frappe.flags.mute_messages = True
						to_remove = False
						ptypes = ("read", )
						if not utils.check_frappe_permission("Jasper Reports", k, ptypes=ptypes):
							continue
						for docname in docnames:
							if not utils.check_frappe_permission(doctype, docname, ptypes=ptypes):
								to_remove = True
								break
						frappe.flags.mute_messages = False
						if to_remove == True:
							continue
					new_data[k] = v
					added = added + 1
		new_data['size'] = added
		return new_data
Ejemplo n.º 3
0
    def run_report(self, data, docdata=None):
        doctype = data.get('doctype')
        rdoc = frappe.get_doc(doctype, data.get('report_name'))

        #call hook before run the report
        utils.call_hook_for_param(rdoc, "jasper_before_run_report", data)

        rtype = rdoc.get("jasper_report_type")
        if data.get("fortype").lower() == "doctype" and rtype in ("List",
                                                                  "Form"):
            for docname in data.get('name_ids', []) or []:
                if not utils.check_frappe_permission(rdoc.jasper_doctype,
                                                     docname,
                                                     ptypes=("read", "print")):
                    raise frappe.PermissionError(
                        _("No {0} permission for document {1} in doctype {3}."
                          ).format("read or print", docname,
                                   rdoc.jasper_doctype))
            #if user can read doc it is possible that can't print it! Just uncheck Read permission in doctype Jasper Reports
        if not utils.check_frappe_permission(
                "Jasper Reports", data.get('report_name', ""), ptypes="read"):
            raise frappe.PermissionError(_("You don't have print permission."))

        params = rdoc.jasper_parameters
        origin = rdoc.jasper_report_origin.lower()
        pformat = data.get('pformat')
        ncopies = get_copies(rdoc, pformat)
        if origin == "localserver":
            path = rdoc.jrxml_root_path
            self.get_server("local")
            if not path:
                frappe.throw(_("%s: Import first a jrxml file." % rdoc.name))
            for_all_sites = rdoc.jasper_all_sites_report
            result = self.jpl.run_local_report_async(
                path,
                rdoc,
                data=data,
                params=params,
                pformat=pformat,
                ncopies=ncopies,
                for_all_sites=for_all_sites)
        else:
            path = rdoc.jasper_report_path
            self.get_server("server")
            if not self.jps.is_login:
                frappe.msgprint(_("Jasper Server, login error."))
                return

            result = self.jps.run_remote_report_async(path,
                                                      rdoc,
                                                      data=data,
                                                      params=params,
                                                      pformat=pformat,
                                                      ncopies=ncopies)
        result[0]["pformat"] = pformat

        return result
Ejemplo n.º 4
0
	def run_report(self, data, docdata=None):
		doctype = data.get('doctype')
		rdoc = frappe.get_doc(doctype, data.get('report_name'))

		#call hook before run the report
		utils.call_hook_for_param(rdoc, "jasper_before_run_report", data)

		rtype = rdoc.get("jasper_report_type")
		if data.get("fortype").lower() == "doctype" and rtype in ("List", "Form"):
			for docname in data.get('name_ids', []) or []:
				if not utils.check_frappe_permission(rdoc.jasper_doctype, docname, ptypes=("read", "print")):
					raise frappe.PermissionError(_("No {0} permission for document {1} in doctype {3}.").format("read or print", docname, rdoc.jasper_doctype))
			#if user can read doc it is possible that can't print it! Just uncheck Read permission in doctype Jasper Reports
		if not utils.check_frappe_permission("Jasper Reports", data.get('report_name', ""), ptypes="read"):
			raise frappe.PermissionError(_("You don't have print permission."))

		params = rdoc.jasper_parameters
		origin = rdoc.jasper_report_origin.lower()
		pformat = data.get('pformat')
		ncopies = get_copies(rdoc, pformat)
		if origin == "localserver":
			path = rdoc.jrxml_root_path
			self.get_server("local")
			if not path:
				frappe.throw(_("%s: Import first a jrxml file." % rdoc.name))
			for_all_sites = rdoc.jasper_all_sites_report
			result = self.jpl.run_local_report_async(path, rdoc, data=data, params=params, pformat=pformat, ncopies=ncopies, for_all_sites=for_all_sites)
		else:
			path = rdoc.jasper_report_path
			self.get_server("server")
			if not self.jps.is_login:
				frappe.msgprint(_("Jasper Server, login error."))
				return

			result = self.jps.run_remote_report_async(path, rdoc, data=data, params=params, pformat=pformat, ncopies=ncopies)
			#result[0]["pformat"] = pformat

		return result
	def filter_perm_roles(self, data):
		removed = 0
		count = 0
		toremove = []
		for k,v in data.iteritems():
			if isinstance(v, dict):
				count += 1
				perms = v.pop("perms", None)
				frappe.flags.mute_messages = True
				found = utils.check_frappe_permission("Jasper Reports", k, ptypes=("read", ))
				frappe.flags.mute_messages = False
				if not found:
					toremove.append(k)
					removed = removed + 1
		for k in toremove:
			data.pop(k, None)
		data['size'] = count - removed
Ejemplo n.º 6
0
	def filter_perm_roles(self, data):
		removed = 0
		count = 0
		toremove = []
		for k,v in data.iteritems():
			if isinstance(v, dict):
				count += 1
				perms = v.pop("perms", None)
				frappe.flags.mute_messages = True
				found = utils.check_frappe_permission("Jasper Reports", k, ptypes=("read", ))
				frappe.flags.mute_messages = False
				if not found:
					toremove.append(k)
					removed = removed + 1
		for k in toremove:
			data.pop(k, None)
		data['size'] = count - removed
Ejemplo n.º 7
0
def jasper_make_email(doctype=None,
                      name=None,
                      content=None,
                      subject=None,
                      sent_or_received="Sent",
                      sender=None,
                      recipients=None,
                      communication_medium="Email",
                      send_email=False,
                      print_html=None,
                      print_format=None,
                      attachments='[]',
                      send_me_a_copy=False,
                      set_lead=True,
                      date=None,
                      jasper_doc=None,
                      docdata=None):

    custom_print_html = print_html
    custom_print_format = print_format

    jasper_polling_time = frappe.db.get_value('JasperServerConfig',
                                              fieldname="jasper_polling_time")
    data = json.loads(jasper_doc)
    result = run_report(data, docdata)
    if result[0].get("status", "not ready") != "ready":
        poll_data = prepare_polling(result)
        result = report_polling(poll_data)
        limit = 0
        while limit <= 10 and result[0].get("status", "not ready") != "ready":
            time.sleep(cint(jasper_polling_time) / 1000)
            result = report_polling(poll_data)
            limit += 1

    pformat = data.get("pformat")
    #we have to remove the original and send only duplicate
    if result[0].get("status", "not ready") == "ready":
        rdoc = frappe.get_doc(data.get("doctype"), data.get('report_name'))
        ncopies = get_copies(rdoc, pformat)
        fileName, jasper_content, report_name = _get_report(result[0])
        merge_all = True
        pages = None
        if pformat == "pdf" and ncopies > 1:
            merge_all = False
            pages = get_pages(ncopies, len(jasper_content))

        sender = get_sender(sender)

        if pformat == "html":
            custom_print_html = True
            url, filepath = make_pdf(fileName,
                                     jasper_content,
                                     pformat,
                                     report_name,
                                     merge_all=merge_all,
                                     pages=pages,
                                     email=True)
            output = filepath
            file_name = output.rsplit("/", 1)
            if len(file_name) > 1:
                file_name = file_name[1]
            else:
                file_name = file_name[0]

        elif pformat == "pdf":
            custom_print_format = "pdf"
            file_name, filepath, output, url = make_pdf(
                fileName,
                jasper_content,
                pformat,
                report_name,
                reqId=result[0].get("requestId"),
                merge_all=merge_all,
                pages=pages,
                email=True)
            output = output.getvalue()

        else:
            file_name, output = make_pdf(fileName,
                                         jasper_content,
                                         pformat,
                                         report_name,
                                         merge_all=merge_all,
                                         pages=pages,
                                         email=True)
            filepath = url = get_email_other_path(data, file_name,
                                                  result[0].get("requestId"),
                                                  sender)
            output = output.getvalue()
            #remove name from filepath
            filepath = filepath.rsplit("/", 1)[0]

    else:
        frappe.throw(
            _("Error generating %s format, try again later.") % (pformat, ))
        frappe.errprint(frappe.get_traceback())
        return

    if not check_frappe_permission(
            data.get("doctype"), data.get('report_name'), ptypes=("read", )):
        raise frappe.PermissionError(
            (_("You are not allowed to send emails related to") +
             ": {doctype} {name}").format(doctype=data.get("doctype"),
                                          name=data.get('report_name')))

    jasper_run_method("jasper_before_sendmail",
                      data,
                      file_name,
                      output,
                      url,
                      doctype=doctype,
                      name=name,
                      content=content,
                      subject=subject,
                      sent_or_received=sent_or_received,
                      sender=sender,
                      recipients=recipients,
                      print_html=print_html,
                      print_format=print_format,
                      attachments=attachments,
                      send_me_a_copy=send_me_a_copy)

    version = getFrappeVersion().major
    if version >= 5:
        file_path = None

        if isinstance(attachments, basestring):
            attachments = json.loads(attachments)

        if pformat != "html":
            file_path = os.path.join(filepath, file_name)
            jasper_save_email(file_path, output)
            attachments.append(file_path)

        comm_name = sendmail_v5(url,
                                doctype=doctype,
                                name=name,
                                content=content,
                                subject=subject,
                                sent_or_received=sent_or_received,
                                sender=sender,
                                recipients=recipients,
                                send_email=send_email,
                                print_html=print_html,
                                print_format=print_format,
                                attachments=attachments)

        set_jasper_email_doctype(data.get('report_name'), recipients, sender,
                                 frappe.utils.now(), url, file_name)
        jasper_run_method("jasper_after_sendmail", data, url, file_name,
                          file_path)

        return comm_name

    print_format = custom_print_format
    print_html = custom_print_html

    sendmail(file_name,
             output,
             url,
             doctype=doctype,
             name=name,
             content=content,
             subject=subject,
             sent_or_received=sent_or_received,
             sender=sender,
             recipients=recipients,
             print_html=print_html,
             print_format=print_format,
             attachments=attachments,
             send_me_a_copy=send_me_a_copy)

    file_path = None
    if pformat != "html":
        file_path = os.path.join(filepath, file_name)
        jasper_save_email(file_path, output)

    set_jasper_email_doctype(data.get('report_name'), recipients, sender,
                             frappe.utils.now(), url, file_name)
    jasper_run_method("jasper_after_sendmail", data, url, file_name, file_path)
Ejemplo n.º 8
0
def get_doc(doctype, docname):
    data = {}
    doc = frappe.get_doc(doctype, docname)
    if check_frappe_permission(doctype, docname, ptypes=("read", )):
        data = {"data": doc}
    frappe.local.response.update(data)
def jasper_make_email(doctype=None, name=None, content=None, subject=None, sent_or_received = "Sent",
	sender=None, recipients=None, communication_medium="Email", send_email=False,
	print_html=None, print_format=None, attachments='[]', send_me_a_copy=False, set_lead=True, date=None,
	jasper_doc=None, docdata=None):

	custom_print_html = print_html
	custom_print_format = print_format

	jasper_polling_time = frappe.db.get_value('JasperServerConfig', fieldname="jasper_polling_time")
	data = json.loads(jasper_doc)
	result = run_report(data, docdata)
	if result[0].get("status", "not ready") != "ready":
		poll_data = prepare_polling(result)
		result = report_polling(poll_data)
		limit = 0
		while limit <= 10 and result[0].get("status", "not ready") != "ready":
			time.sleep(cint(jasper_polling_time)/1000)
			result = report_polling(poll_data)
			limit += 1

	pformat = data.get("pformat")
	#we have to remove the original and send only duplicate
	if result[0].get("status", "not ready") == "ready":
		rdoc = frappe.get_doc(data.get("doctype"), data.get('report_name'))
		ncopies = get_copies(rdoc, pformat)
		fileName, jasper_content, report_name = _get_report(result[0])
		merge_all = True
		pages = None
		if pformat == "pdf" and ncopies > 1:
			merge_all = False
			pages = get_pages(ncopies, len(jasper_content))

		sender = get_sender(sender)

		if pformat == "html":
			custom_print_html = True
			url, filepath = make_pdf(fileName, jasper_content, pformat, report_name, merge_all=merge_all, pages=pages, email=True)
			output = filepath
			file_name = output.rsplit("/",1)
			if len(file_name) > 1:
				file_name = file_name[1]
			else:
				file_name = file_name[0]


		elif pformat == "pdf":
			custom_print_format = "pdf"
			file_name, filepath, output, url = make_pdf(fileName, jasper_content, pformat, report_name, reqId=result[0].get("requestId"), merge_all=merge_all, pages=pages, email=True)
			output = output.getvalue()

		else:
			file_name, output = make_pdf(fileName, jasper_content, pformat, report_name, merge_all=merge_all, pages=pages, email=True)
			filepath = url = get_email_other_path(data, file_name, result[0].get("requestId"), sender)
			output = output.getvalue()
			#remove name from filepath
			filepath = filepath.rsplit("/",1)[0]

	else:
		frappe.throw(_("Error generating %s format, try again later.") % (pformat,))
		frappe.errprint(frappe.get_traceback())
		return

	if not check_frappe_permission(data.get("doctype"), data.get('report_name'), ptypes=("read", )):
		raise frappe.PermissionError((_("You are not allowed to send emails related to") + ": {doctype} {name}").format(
			doctype=data.get("doctype"), name=data.get('report_name')))

	jasper_run_method("jasper_before_sendmail", data, file_name, output, url, doctype=doctype, name=name, content=content, subject=subject, sent_or_received=sent_or_received,
		sender=sender, recipients=recipients, print_html=print_html, print_format=print_format, attachments=attachments,
		send_me_a_copy=send_me_a_copy)

	version = getFrappeVersion().major
	if version >= 5:
		file_path = None

		if isinstance(attachments, basestring):
			attachments = json.loads(attachments)

		if pformat != "html":
			file_path = os.path.join(filepath, file_name)
			jasper_save_email(file_path, output)
			attachments.append(file_path)

		comm_name = sendmail_v5(url, doctype=doctype, name=name, content=content, subject=subject, sent_or_received=sent_or_received,
				sender=sender, recipients=recipients, send_email=send_email, print_html=print_html, print_format=print_format, attachments=attachments)

		set_jasper_email_doctype(data.get('report_name'), recipients, sender, frappe.utils.now(), url, file_name)
		jasper_run_method("jasper_after_sendmail", data, url, file_name, file_path)

		return comm_name

	print_format = custom_print_format
	print_html = custom_print_html

	sendmail(file_name, output, url, doctype=doctype, name=name, content=content, subject=subject, sent_or_received=sent_or_received,
		sender=sender, recipients=recipients, print_html=print_html, print_format=print_format, attachments=attachments,
		send_me_a_copy=send_me_a_copy)

	file_path = None
	if pformat != "html":
		file_path = os.path.join(filepath, file_name)
		jasper_save_email(file_path, output)

	set_jasper_email_doctype(data.get('report_name'), recipients, sender, frappe.utils.now(), url, file_name)
	jasper_run_method("jasper_after_sendmail", data, url, file_name, file_path)
Ejemplo n.º 10
0
def get_doc(doctype, docname):
	data = {}
	doc = frappe.get_doc(doctype, docname)
	if check_frappe_permission(doctype, docname, ptypes=("read", )):
		data = {"data": doc}
	frappe.local.response.update(data)