Beispiel #1
0
def setup_complete(args):
	"""Calls hooks for `setup_wizard_complete`, sets home page as `desktop`
	and clears cache. If wizard breaks, calls `setup_wizard_exception` hook"""

	# Setup complete: do not throw an exception, let the user continue to desk
	if cint(frappe.db.get_single_value('System Settings', 'setup_complete')):
		return

	args = parse_args(args)

	stages = get_setup_stages(args)

	try:
		current_task = None
		for idx, stage in enumerate(stages):
			frappe.publish_realtime('setup_task', {"progress": [idx, len(stages)],
				"stage_status": stage.get('status')}, user=frappe.session.user)

			for task in stage.get('tasks'):
				current_task = task
				task.get('fn')(task.get('args'))

	except Exception:
		handle_setup_exception(args)
		return {'status': 'fail', 'fail': current_task.get('fail_msg')}
	else:
		run_setup_success(args)
		return {'status': 'ok'}
Beispiel #2
0
    def set_delivery_status(self, commit=False):
        """Look into the status of Bulk Email linked to this Communication and set the Delivery Status of this Communication"""
        delivery_status = None
        status_counts = Counter(
            frappe.db.sql_list("""select status from `tabBulk Email` where communication=%s""", self.name)
        )

        if status_counts.get("Not Sent") or status_counts.get("Sending"):
            delivery_status = "Sending"

        elif status_counts.get("Error"):
            delivery_status = "Error"

        elif status_counts.get("Expired"):
            delivery_status = "Expired"

        elif status_counts.get("Sent"):
            delivery_status = "Sent"

        if delivery_status:
            self.db_set("delivery_status", delivery_status)

            frappe.publish_realtime(
                "update_communication",
                self.as_dict(),
                doctype=self.reference_doctype,
                docname=self.reference_name,
                after_commit=True,
            )

            # for list views and forms
            self.notify_update()

            if commit:
                frappe.db.commit()
Beispiel #3
0
def bulk_clone(name):
	source_plant = frappe.get_doc("Plant", name)

	if source_plant.qty > 1:
		warehouse = frappe.get_doc("Warehouse", source_plant.get("warehouse"))
		location = frappe.get_value("BioTrack Settings", None, "location")
		remaining_qty = source_plant.qty - 1

		result = biotrackthc_call("plant_new", {
			"room": warehouse.external_id,
			"quantity": remaining_qty,
			"strain": source_plant.strain,
			"source": source_plant.item_code,
			"mother": cint(source_plant.get("is_mother")),
			"location": location
		})

		for barcode in result.get("barcode_id"):
			plant = frappe.new_doc("Plant")
			plant.update({
				"barcode": barcode,
				"item_group": source_plant.item_group,
				"source": source_plant.item_code,
				"strain": source_plant.strain,
				"warehouse": source_plant.warehouse,
				"state": source_plant.state,
				"birthdate": now(),
			})

			plant.save()

		# save directly with sql to avoid mistimestamp check
		frappe.db.set_value("Plant", source_plant.name, "qty", 1, update_modified=False)
		frappe.publish_realtime("list_update", {"doctype": "Plant"})
Beispiel #4
0
def migrate(verbose=True, rebuild_website=False):
	'''Migrate all apps to the latest version, will:

	- run patches
	- sync doctypes (schema)
	- sync fixtures
	- sync desktop icons
	- sync web pages (from /www)'''
	clear_global_cache()

	# run patches
	frappe.modules.patch_handler.run_all()
	# sync
	frappe.model.sync.sync_all(verbose=verbose)
	frappe.translate.clear_cache()
	sync_fixtures()
	sync_desktop_icons()

	# syncs statics
	render.clear_cache()
	if rebuild_website:
		statics.sync(verbose=verbose).start(True)
	else:
		statics.sync_statics()

	frappe.db.commit()

	clear_notifications()

	frappe.publish_realtime("version-update")
Beispiel #5
0
def migrate(context, rebuild_website=False):
	"Run patches, sync schema and rebuild files/translations"
	import frappe.modules.patch_handler
	import frappe.model.sync
	from frappe.utils.fixtures import sync_fixtures
	import frappe.translate
	from frappe.desk.notifications import clear_notifications

	for site in context.sites:
		print 'Migrating', site
		frappe.init(site=site)
		frappe.connect()

		try:
			prepare_for_update()

			# run patches
			frappe.modules.patch_handler.run_all()
			# sync
			frappe.model.sync.sync_all(verbose=context.verbose)
			frappe.translate.clear_cache()
			sync_fixtures()

			clear_notifications()
		finally:
			frappe.publish_realtime("version-update")
			frappe.destroy()

	if rebuild_website:
		call_command(build_website, context)
	else:
		call_command(sync_www, context)
Beispiel #6
0
def run_background(prepared_report):
	instance = frappe.get_doc("Prepared Report", prepared_report)
	report = frappe.get_doc("Report", instance.ref_report_doctype)

	try:
		report.custom_columns = []

		if report.report_type == 'Custom Report':
			custom_report_doc = report
			reference_report = custom_report_doc.reference_report
			report = frappe.get_doc("Report", reference_report)
			report.custom_columns = custom_report_doc.json

		result = generate_report_result(report, filters=instance.filters, user=instance.owner)
		create_json_gz_file(result['result'], 'Prepared Report', instance.name)

		instance.status = "Completed"
		instance.columns = json.dumps(result["columns"])
		instance.report_end_time = frappe.utils.now()
		instance.save()

	except Exception:
		frappe.log_error(frappe.get_traceback())
		instance = frappe.get_doc("Prepared Report", prepared_report)
		instance.status = "Error"
		instance.error_message = frappe.get_traceback()
		instance.save()

	frappe.publish_realtime(
		'report_generated',
		{"report_name": instance.report_name, "name": instance.name},
		user=frappe.session.user
	)
	def set_delivery_status(self, commit=False):
		'''Look into the status of Bulk Email linked to this Communication and set the Delivery Status of this Communication'''
		delivery_status = None
		status_counts = Counter(frappe.db.sql_list('''select status from `tabBulk Email` where communication=%s''', self.name))

		if status_counts.get('Not Sent') or status_counts.get('Sending'):
			delivery_status = 'Sending'

		elif status_counts.get('Error'):
			delivery_status = 'Error'

		elif status_counts.get('Expired'):
			delivery_status = 'Expired'

		elif status_counts.get('Sent'):
			delivery_status = 'Sent'

		if delivery_status:
			self.db_set('delivery_status', delivery_status)

			frappe.publish_realtime('update_communication', self.as_dict(),
				doctype=self.reference_doctype, docname=self.reference_name, after_commit=True)

			# for list views and forms
			self.notify_update()

			if commit:
				frappe.db.commit()
def install_app(name):
	"""Install app, if app is not installed in local environment, install it via git url in
	`frappe/data/app_listing/`"""
	frappe.only_for("System Manager")

	if name not in frappe.get_all_apps(True):
		if not frappe.conf.disallow_app_listing:
			get_app(name)
			frappe.cache().delete_value(["app_hooks"])
			# reload sys.path
			import site
			reload(site)
		else:
			# will only come via direct API
			frappe.throw("Listing app not allowed")

	app_hooks = frappe.get_hooks(app_name=name)
	if app_hooks.get('hide_in_installer'):
		frappe.throw(_("You cannot install this app"))

	frappe.publish_realtime("install_app_progress", {"status": _("Installing App {0}").format(name)},
		user=frappe.session.user, now=True)

	frappe.installer.install_app(name)

	frappe.publish_realtime("install_app_progress", {"status": _("{0} Installed").format(name)},
		user=frappe.session.user, now=True)
Beispiel #9
0
def verifica_check_in():

		# loop no Doc a procura de quartos com limite da DATA de ENTRADA.

		for d in frappe.db.sql("""SELECT codigo,numero_quarto,check_in,check_out,reservation_status, pay_advance FROM `tabRESERVAS` WHERE reservation_status = "Nova" and check_in <=%s """, frappe.utils.now(), as_dict=True):
			print "RESERVAS +++++++++++++++++++++++++++++++"
			if (frappe.utils.data.time_diff_in_hours(frappe.utils.now(),d.check_in) >2):
				
				reser = frappe.get_doc("RESERVAS",d.codigo)
				dd= datetime.datetime.fromtimestamp(frappe.utils.data.time_diff_in_hours(frappe.utils.now(),d.check_in)).strftime('%H:%M:%S')

# str(frappe.utils.data.time_diff_in_hours(frappe.utils.now(),d.check_in))

				ddd = make_autoname('CANCEL/' + '.#####')
				print " Numer " + ddd
				frappe.db.sql("INSERT into tabCommunication  (name,docstatus,seen,unread_notification_sent,subject,reference_name,reference_doctype,sent_or_received,content,communication_type,creation,modified) values (%s,0,0,0,'RESERVA Cancelada ',%s,'RESERVAS','Sent','RESERVA Cancelada  <!-- markdown -->','Comment',%s,%s) ",(ddd,d.codigo,frappe.utils.now(),frappe.utils.now()))

#				reser._comments =[{"comment": "Reserva " + d.codigo + " " + str(d.check_in) + " Cancelada por mais de " + datetime.datetime.fromtimestamp(dd).strftime('%H:%M:%S') + " horas; by name: " + ddd}]

				reser._comments = "Reserva " + str(d.codigo) + " " + str(d.check_in) + " Cancelada por mais de " + dd + " horas"

				print " AGORA " + frappe.utils.now()
				print " CHECK IN " + str(d.check_in)
				print "Reserva " + d.codigo + " " + str(d.check_in) + " Cancelada por mais de " + dd + " horas"
				reser.reservation_status="Cancelada"
				reser.save()
				#frappe.redirect_to_message(_('INFORMACAO RESERVAS'),"<div>RESERVA " + d.codigo + " FOI CANCELADA </div>")	
				frappe.publish_realtime(event='msgprint', message='RESERVA ' + d.codigo + ' ' + str(d.check_in) + ' Cancelada por mais de ' + dd + ' horas', user=frappe.session.user,doctype='RESERVAS')	
Beispiel #10
0
	def create_student_groups(self):
		if not self.courses:
			frappe.throw(_("""No Student Groups created."""))

		l = len(self.courses)
		for d in self.courses:
			if not d.student_group_name:
				frappe.throw(_("""Student Group Name is mandatory in row {0}""".format(d.idx)))

			if d.group_based_on == "Course" and not d.course:
				frappe.throw(_("""Course is mandatory in row {0}""".format(d.idx)))

			if d.group_based_on == "Batch" and not d.batch:
				frappe.throw(_("""Batch is mandatory in row {0}""".format(d.idx)))

			frappe.publish_realtime('student_group_creation_progress', {"progress": [d.idx, l]}, user=frappe.session.user)

			student_group = frappe.new_doc("Student Group")
			student_group.student_group_name = d.student_group_name
			student_group.group_based_on = d.group_based_on
			student_group.program = self.program
			student_group.course = d.course
			student_group.batch = d.batch
			student_group.max_strength = d.max_strength
			student_group.academic_term = self.academic_term
			student_group.academic_year = self.academic_year
			student_list = get_students(self.academic_year, d.group_based_on, self.academic_term, self.program, d.batch, d.course)

			for student in student_list:
				student_group.append('students', student)
			student_group.save()

		frappe.msgprint(_("{0} Student Groups created.".format(l)))
Beispiel #11
0
def migrate(verbose=True, rebuild_website=False):
	'''Migrate all apps to the latest version, will:
	- run before migrate hooks
	- run patches
	- sync doctypes (schema)
	- sync fixtures
	- sync desktop icons
	- sync web pages (from /www)
	- sync web pages (from /www)
	- run after migrate hooks
	'''

	touched_tables_file = frappe.get_site_path('touched_tables.json')
	if os.path.exists(touched_tables_file):
		os.remove(touched_tables_file)

	try:
		frappe.flags.touched_tables = set()
		frappe.flags.in_migrate = True
		clear_global_cache()

		#run before_migrate hooks
		for app in frappe.get_installed_apps():
			for fn in frappe.get_hooks('before_migrate', app_name=app):
				frappe.get_attr(fn)()

		# run patches
		frappe.modules.patch_handler.run_all()
		# sync
		frappe.model.sync.sync_all(verbose=verbose)
		frappe.translate.clear_cache()
		sync_fixtures()
		sync_customizations()
		sync_desktop_icons()
		sync_languages()

		frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()

		# syncs statics
		render.clear_cache()

		# add static pages to global search
		router.sync_global_search()

		#run after_migrate hooks
		for app in frappe.get_installed_apps():
			for fn in frappe.get_hooks('after_migrate', app_name=app):
				frappe.get_attr(fn)()

		frappe.db.commit()

		clear_notifications()

		frappe.publish_realtime("version-update")
		frappe.flags.in_migrate = False
	finally:
		with open(touched_tables_file, 'w') as f:
			json.dump(list(frappe.flags.touched_tables), f, sort_keys=True, indent=4)
		frappe.flags.touched_tables.clear()
Beispiel #12
0
	def notify_update(self):
		"""Publish realtime that the current document is modified"""
		frappe.publish_realtime("doc_update", {"modified": self.modified, "doctype": self.doctype, "name": self.name},
			doctype=self.doctype, docname=self.name, after_commit=True)

		if not self.meta.get("read_only") and not self.meta.get("issingle") and \
			not self.meta.get("istable"):
			frappe.publish_realtime("list_update", {"doctype": self.doctype}, after_commit=True)
Beispiel #13
0
def start_install(name):
	frappe.publish_realtime("install_app_progress", {"status": _("Installing App {0}").format(name)},
		user=frappe.session.user)

	frappe.installer.install_app(name)

	frappe.publish_realtime("install_app_progress", {"status": _("{0} Installed").format(name)},
		user=frappe.session.user)
    def after_insert(self):
        # send new comment to listening clients
        comment = self.as_dict()
        comment["comment"] = comment["content"]
        comment["comment_by"] = comment["sender"]
        comment["comment_type"] = comment["communication_medium"]

        frappe.publish_realtime("new_comment", comment, doctype=self.reference_doctype, docname=self.reference_name)
Beispiel #15
0
def import_data(data_import):
	frappe.db.set_value("Data Import", data_import, "import_status", "In Progress", update_modified=False)
	frappe.publish_realtime("data_import_progress", {"progress": "0",
		"data_import": data_import, "reload": True}, user=frappe.session.user)
	from frappe.core.page.background_jobs.background_jobs import get_info
	enqueued_jobs = [d.get("job_name") for d in get_info()]
	if data_import not in enqueued_jobs:
		enqueue(upload, queue='default', timeout=6000, event='data_import', job_name=data_import,
			data_import_doc=data_import, from_data_import="Yes", user=frappe.session.user)
Beispiel #16
0
	def receive(self, test_mails=None):
		"""Called by scheduler to receive emails from this EMail account using POP3/IMAP."""
		if self.enable_incoming:
			exceptions = []
			if frappe.local.flags.in_test:
				incoming_mails = test_mails
			else:
				email_server = self.get_server(in_receive=True)
				if not email_server:
					return
				try:
					incoming_mails = email_server.get_messages()
				except Exception as e:
					frappe.db.sql("update `tabEmail Account` set no_remaining = NULL where name = %s",(self.name), auto_commit=1)
					incoming_mails = []

			for msg in incoming_mails:
				try:

					communication = self.insert_communication(msg)
					#self.notify_update()

				except SentEmailInInbox as e:
					frappe.db.rollback()
					if self.use_imap:
						self.handle_bad_emails(email_server, msg[1], msg[0], "sent email in inbox")


				except Exception as e:
					frappe.db.rollback()
					log('email_account.receive')
					if self.use_imap:
						self.handle_bad_emails(email_server, msg[1], msg[0], frappe.get_traceback())
					exceptions.append(frappe.get_traceback())

				else:
					frappe.db.commit()
					attachments = [d.file_name for d in communication._attachments]

					if communication.message_id and not communication.timeline_hide:
						first = frappe.db.get_value("Communication", {"message_id": communication.message_id},["name"],order_by="creation",as_dict=1)
						if first:
							if first.name != communication.name:
								frappe.db.sql("""update tabCommunication set timeline_hide =%s where name = %s""",(first.name,communication.name),auto_commit=1)

					if self.no_remaining == '0' and not frappe.local.flags.in_test:
						if communication.reference_doctype :
							if not communication.timeline_hide and not communication.unread_notification_sent:
								communication.notify(attachments=attachments, fetched_from_email_account=True)

			#notify if user is linked to account
			if len(incoming_mails)>0 and not frappe.local.flags.in_test:
				frappe.publish_realtime('new_email', {"account":self.email_account_name, "account_name": self.name, "number":len(incoming_mails)})

			if exceptions:
				raise Exception, frappe.as_json(exceptions)
Beispiel #17
0
def create(kind, owner, users = None, name = None):
	authenticate(owner)

	users  = safe_json_loads(users)
	create = True

	if kind == 'Visitor':
		room = squashify(frappe.db.sql("""
			SELECT name
			FROM   `tabChat Room`
			WHERE  owner = "{owner}"
		""".format(owner = owner), as_dict = True))

		if room:
			room   = frappe.get_doc('Chat Room', room.name)
			create = False

	if create:
		room  		   = frappe.new_doc('Chat Room')
		room.type 	   = kind
		room.owner	   = owner
		room.room_name = name

	dusers = [ ]

	if kind != 'Visitor':
		if users:
			users  = listify(users)
			for user in users:
				duser 	   = frappe.new_doc('Chat Room User')
				duser.user = user
				dusers.append(duser)

			room.users = dusers
	else:
		dsettings	   = frappe.get_single('Website Settings')
		room.room_name = dsettings.chat_room_name

		users          = [user for user in room.users] if hasattr(room, 'users') else [ ]

		for user in dsettings.chat_operators:
			if user.user not in users:
				# appending user to room.users will remove the user from chat_operators
				# this is undesirable, create a new Chat Room User instead
				chat_room_user = {"doctype": "Chat Room User", "user": user.user}
				room.append('users', chat_room_user)

	room.save(ignore_permissions = True)

	room  = get(owner, rooms = room.name)
	users = [room.owner] + [u for u in room.users]

	for u in users:
		frappe.publish_realtime('frappe.chat.room:create', room, user = u, after_commit = True)

	return room
Beispiel #18
0
def generate_csrf_token():
	frappe.local.session.data.csrf_token = frappe.generate_hash()
	frappe.local.session_obj.update(force=True)

	# send sid and csrf token to the user
	# handles the case when a user logs in again from another tab
	# and it leads to invalid request in the current tab
	frappe.publish_realtime(event="csrf_generated",
		message={"sid": frappe.local.session.sid, "csrf_token": frappe.local.session.data.csrf_token},
		user=frappe.session.user)
Beispiel #19
0
def seen(message, user = None):
	authenticate(user)

	mess = frappe.get_doc('Chat Message', message)
	mess.add_seen(user)

	room = mess.room
	resp = dict(message = message, data = dict(seen = json.loads(mess._seen)))

	frappe.publish_realtime('frappe.chat.message:update', resp, room = room, after_commit = True)
Beispiel #20
0
	def reload_linked_analysis(self):
		linked_doctypes = ['Soil Texture', 'Soil Analysis', 'Plant Analysis']
		required_fields = ['location', 'name', 'collection_datetime']
		output = {}
		for doctype in linked_doctypes:
			output[doctype] = frappe.get_all(doctype, fields=required_fields)
		output['Land Unit'] = []
		for land in self.linked_land_unit:
			output['Land Unit'].append(frappe.get_doc('Land Unit', land.land_unit))

		frappe.publish_realtime("List of Linked Docs", output, user=frappe.session.user)
	def after_insert(self):
		if not (self and self.name):
			return

		# Obtains the conversation linked to this Livechat Message
		conversation = frappe.get_doc('Chat Conversation', self.parent)
		# Sends new comment to listening clients so they get a realtime update
		frappe.publish_realtime('new_message', self.as_dict(),
				doctype= 'Chat Conversation', docname = conversation.name,
				after_commit=True)
		frappe.publish_realtime(event='livechat_update', message='''{u'doctype': u'Livechat Message'}''')
Beispiel #22
0
def publish_realtime(context, event, message, room, user, doctype, docname, after_commit):
	"Publish realtime event from bench"
	from frappe import publish_realtime
	for site in context.sites:
		try:
			frappe.init(site=site)
			frappe.connect()
			publish_realtime(event, message=message, room=room, user=user, doctype=doctype, docname=docname,
				after_commit=after_commit)
			frappe.db.commit()
		finally:
			frappe.destroy()
Beispiel #23
0
	def on_trash(self):
		if (not self.flags.ignore_permissions
			and self.communication_type=="Comment" and self.comment_type != "Comment"):

			# prevent deletion of auto-created comments if not ignore_permissions
			frappe.throw(_("Sorry! You cannot delete auto-generated comments"))

		if self.communication_type in ("Communication", "Comment"):
			# send delete comment to listening clients
			frappe.publish_realtime('delete_communication', self.as_dict(),
				doctype= self.reference_doctype, docname = self.reference_name,
				after_commit=True)
Beispiel #24
0
	def create_fees(self):
		self.db_set("fee_creation_status", "In Process")
		frappe.publish_realtime("fee_schedule_progress",
			{"progress": "0", "reload": 1}, user=frappe.session.user)

		total_records = sum([int(d.total_students) for d in self.student_groups])
		if total_records > 10:
			frappe.msgprint(_('''Fee records will be created in the background.
				In case of any error the error message will be updated in the Schedule.'''))
			enqueue(generate_fee, queue='default', timeout=6000, event='generate_fee',
				fee_schedule=self.name)
		else:
			generate_fee(self.name)
	def make_invoices(self):
		names = []
		mandatory_error_msg = _("Row {0}: {1} is required to create the Opening {2} Invoices")
		if not self.company:
			frappe.throw(_("Please select the Company"))

		for row in self.invoices:
			if not row.qty:
				row.qty = 1.0

			# always mandatory fields for the invoices
			if not row.temporary_opening_account:
				row.temporary_opening_account = get_temporary_opening_account(self.company)
			row.party_type = "Customer" if self.invoice_type == "Sales" else "Supplier"

			# Allow to create invoice even if no party present in customer or supplier.
			if not frappe.db.exists(row.party_type, row.party):
				if self.create_missing_party:
					self.add_party(row.party_type, row.party)
				else:
					frappe.throw(_("{0} {1} does not exist.").format(frappe.bold(row.party_type), frappe.bold(row.party)))

			if not row.item_name:
				row.item_name = _("Opening Invoice Item")
			if not row.posting_date:
				row.posting_date = nowdate()
			if not row.due_date:
				row.due_date = nowdate()

			for d in ("Party", "Outstanding Amount", "Temporary Opening Account"):
				if not row.get(scrub(d)):
					frappe.throw(mandatory_error_msg.format(row.idx, _(d), self.invoice_type))

			args = self.get_invoice_dict(row=row)
			if not args:
				continue

			doc = frappe.get_doc(args).insert()
			doc.submit()
			names.append(doc.name)

			if len(self.invoices) > 5:
				frappe.publish_realtime(
					"progress", dict(
						progress=[row.idx, len(self.invoices)],
						title=_('Creating {0}').format(doc.doctype)
					),
					user=frappe.session.user
				)

		return names
Beispiel #26
0
def generate_fee(fee_schedule):
	doc = frappe.get_doc("Fee Schedule", fee_schedule)
	error = False
	total_records = sum([int(d.total_students) for d in doc.student_groups])
	created_records = 0

	if not total_records:
		frappe.throw(_("Please setup Students under Student Groups"))

	for d in doc.student_groups:
		students = frappe.db.sql(""" select sg.program, sg.batch, sgs.student, sgs.student_name
			from `tabStudent Group` sg, `tabStudent Group Student` sgs
			where sg.name=%s and sg.name=sgs.parent and sgs.active=1""", d.student_group, as_dict=1)

		for student in students:
			try:
				fees_doc = get_mapped_doc("Fee Schedule", fee_schedule,	{
					"Fee Schedule": {
						"doctype": "Fees",
						"field_map": {
							"name": "Fee Schedule"
						}
					}
				})
				fees_doc.student = student.student
				fees_doc.student_name = student.student_name
				fees_doc.program = student.program
				fees_doc.student_batch = student.batch
				fees_doc.send_payment_request = doc.send_email
				fees_doc.save()
				fees_doc.submit()
				created_records += 1
				frappe.publish_realtime("fee_schedule_progress", {"progress": str(int(created_records * 100/total_records))}, user=frappe.session.user)

			except Exception as e:
				error = True
				err_msg = frappe.local.message_log and "\n\n".join(frappe.local.message_log) or cstr(e)

	if error:
		frappe.db.rollback()
		frappe.db.set_value("Fee Schedule", fee_schedule, "fee_creation_status", "Failed")
		frappe.db.set_value("Fee Schedule", fee_schedule, "error_log", err_msg)

	else:
		frappe.db.set_value("Fee Schedule", fee_schedule, "fee_creation_status", "Successful")
		frappe.db.set_value("Fee Schedule", fee_schedule, "error_log", None)

	frappe.publish_realtime("fee_schedule_progress",
		{"progress": "100", "reload": 1}, user=frappe.session.user)
Beispiel #27
0
def realtime_eval(rte_id, tag, event, msg):
    """
    Use publish_realtime to run javascript code using custom event handler.

    rte_id: persistent id for the current form
    tag: communications tag specific to one series of communications
    event: name of custom event to trigger on client.
    msg: JSON serializable object (e.g. dict) to push to client.
    """

    rte_msg = json.dumps(msg)
    js = "erpnext_ebay_realtime_event('{}', '{}', '{}', '{}');"
    js = js.format(rte_id, tag, event, rte_msg)
    frappe.publish_realtime(event='eval_js', message=js,
                            user=frappe.session.user)
Beispiel #28
0
def run_background(instance):
	report = frappe.get_doc("Report", instance.ref_report_doctype)
	result = generate_report_result(report, filters=instance.filters, user=instance.owner)
	create_json_gz_file(result['result'], 'Prepared Report', instance.name)

	instance.status = "Completed"
	instance.columns = json.dumps(result["columns"])
	instance.report_end_time = frappe.utils.now()
	instance.save()

	frappe.publish_realtime(
		'report_generated',
		{"report_name": instance.report_name, "name": instance.name},
		user=frappe.session.user
	)
Beispiel #29
0
def migrate(verbose=True, rebuild_website=False):
	'''Migrate all apps to the latest version, will:
	- run before migrate hooks
	- run patches
	- sync doctypes (schema)
	- sync fixtures
	- sync desktop icons
	- sync web pages (from /www)
	- sync web pages (from /www)
	- run after migrate hooks
	'''
	frappe.flags.in_migrate = True
	clear_global_cache()

	#run before_migrate hooks
	for app in frappe.get_installed_apps():
		for fn in frappe.get_hooks('before_migrate', app_name=app):
			frappe.get_attr(fn)()

	# run patches
	frappe.modules.patch_handler.run_all()
	# sync
	frappe.model.sync.sync_all(verbose=verbose)
	frappe.translate.clear_cache()
	sync_fixtures()
	sync_customizations()
	sync_desktop_icons()
	sync_languages()

	frappe.get_doc('Portal Settings', 'Portal Settings').sync_menu()

	# syncs statics
	render.clear_cache()

	# add static pages to global search
	router.sync_global_search()

	#run after_migrate hooks
	for app in frappe.get_installed_apps():
		for fn in frappe.get_hooks('after_migrate', app_name=app):
			frappe.get_attr(fn)()

	frappe.db.commit()

	clear_notifications()

	frappe.publish_realtime("version-update")
	frappe.flags.in_migrate = False
Beispiel #30
0
def delete_items():
	"""delete selected items"""
	import json

	il = json.loads(frappe.form_dict.get('items'))
	doctype = frappe.form_dict.get('doctype')

	for i, d in enumerate(il):
		try:
			frappe.delete_doc(doctype, d)
			if len(il) >= 5:
				frappe.publish_realtime("progress",
					dict(progress=[i+1, len(il)], title=_('Deleting {0}').format(doctype)),
					user=frappe.session.user)
		except Exception:
			pass
Beispiel #31
0
def long_job(arg1, arg2):

    frappe.publish_realtime('msgprint', 'Starting long job...')

    doc = frappe.get_doc('OpenRouteService')
    client = ors.Client(key=doc.api_openrouteservice)
    home_address = doc.address_line1 + ", " + doc.pincode + " " + doc.city

    home_address_location = client.pelias_search(text=home_address)
    home_address_coordinates = home_address_location["features"][0][
        "geometry"]["coordinates"]

    # get list of all adresses
    all_adresses = frappe.db.get_list("Address", fields=['name'], as_list=True)

    for i in all_adresses:
        # strip it from
        address_id = i[0]

        print(address_id)

        address_line1 = frappe.db.get_value("Address", address_id,
                                            "address_line1")
        pincode = frappe.db.get_value("Address", address_id, "pincode")
        city = frappe.db.get_value("Address", address_id, "city")

        destination_address = str(address_line1) + ", " + str(
            pincode) + " " + str(city)

        print(destination_address)

        destination_address_location = client.pelias_search(
            text=destination_address)

        destination_address_coordinates = destination_address_location[
            "features"][0]["geometry"]["coordinates"]

        print(destination_address_coordinates)

        coordinates = [
            home_address_coordinates, destination_address_coordinates
        ]

        route = client.directions(coordinates=coordinates,
                                  profile='driving-car',
                                  geometry_simplify=True,
                                  instructions=False,
                                  geometry=False)

        distance_and_duration = route.get("routes")[0].get("summary")

        print(distance_and_duration)

        try:
            distance = distance_and_duration["distance"]
            distance = distance / 1000
        except:
            distance = 0
        try:
            duration = distance_and_duration["duration"]
            duration = duration / 60
        except:
            duration = 0

        frappe.db.set_value("Address", address_id, "distance", distance)
        frappe.db.set_value("Address", address_id,
                            "duration_from_home_address_in_minutes", duration)

        time.sleep(1.6)

    frappe.publish_realtime('msgprint', 'Ending long job...')

    return distance, duration
Beispiel #32
0
def run_command(commands,
                doctype,
                key,
                cwd='..',
                docname=' ',
                after_command=None):
    verify_whitelisted_call()
    start_time = frappe.utils.time.time()
    console_dump = ''
    logged_command = ' && '.join(commands)
    logged_command += ' '  #to make sure passwords at the end of the commands are also hidden
    sensitive_data = [
        "--mariadb-root-password", "--admin-password", "--root-password"
    ]
    for password in sensitive_data:
        logged_command = re.sub("{password} .*? ".format(password=password),
                                '',
                                logged_command,
                                flags=re.DOTALL)
    doc = frappe.get_doc({
        'doctype': 'Bench Manager Command',
        'key': key,
        'source': doctype + ': ' + docname,
        'command': logged_command,
        'console': console_dump,
        'status': 'Ongoing'
    })
    doc.insert()
    frappe.db.commit()
    frappe.publish_realtime(key,
                            "Executing Command:\n{logged_command}\n\n".format(
                                logged_command=logged_command),
                            user=frappe.session.user)
    try:
        for command in commands:
            terminal = Popen(shlex.split(command),
                             stdin=PIPE,
                             stdout=PIPE,
                             stderr=STDOUT,
                             cwd=cwd)
            for c in iter(lambda: terminal.stdout.read(1), ''):
                frappe.publish_realtime(key, c, user=frappe.session.user)
                console_dump += c
        if terminal.wait():
            _close_the_doc(start_time,
                           key,
                           console_dump,
                           status='Failed',
                           user=frappe.session.user)
        else:
            _close_the_doc(start_time,
                           key,
                           console_dump,
                           status='Success',
                           user=frappe.session.user)
    except:
        _close_the_doc(start_time,
                       key,
                       console_dump,
                       status='Failed',
                       user=frappe.session.user)
    finally:
        frappe.db.commit()
        # hack: frappe.db.commit() to make sure the log created is robust,
        # and the _refresh throws an error if the doc is deleted
        frappe.enqueue('bench_manager.bench_manager.utils._refresh',
                       doctype=doctype,
                       docname=docname,
                       commands=commands)
Beispiel #33
0
    def import_data(self):
        # set user lang for translations
        frappe.cache().hdel("lang", frappe.session.user)
        frappe.set_user_lang(frappe.session.user)

        if not self.console:
            self.data_import.db_set("template_warnings", "")

        # set flags
        frappe.flags.in_import = True
        frappe.flags.mute_emails = self.data_import.mute_emails

        # prepare a map for missing link field values
        self.prepare_missing_link_field_values()

        # parse docs from rows
        payloads = self.get_payloads_for_import()

        # dont import if there are non-ignorable warnings
        warnings = [w for w in self.warnings if w.get("type") != "info"]
        if warnings:
            if self.console:
                self.print_grouped_warnings(warnings)
            else:
                self.data_import.db_set("template_warnings",
                                        json.dumps(warnings))
                frappe.publish_realtime("data_import_refresh",
                                        {"data_import": self.data_import.name})
            return

        # setup import log
        if self.data_import.import_log:
            import_log = frappe.parse_json(self.data_import.import_log)
        else:
            import_log = []

        # remove previous failures from import log
        import_log = [l for l in import_log if l.get("success") == True]

        # get successfully imported rows
        imported_rows = []
        for log in import_log:
            log = frappe._dict(log)
            if log.success:
                imported_rows += log.row_indexes

        # start import
        total_payload_count = len(payloads)
        batch_size = frappe.conf.data_import_batch_size or 1000

        for batch_index, batched_payloads in enumerate(
                frappe.utils.create_batch(payloads, batch_size)):
            for i, payload in enumerate(batched_payloads):
                doc = payload.doc
                row_indexes = [row[0] for row in payload.rows]
                current_index = (i + 1) + (batch_index * batch_size)

                if set(row_indexes).intersection(set(imported_rows)):
                    print("Skipping imported rows", row_indexes)
                    if total_payload_count > 5:
                        frappe.publish_realtime(
                            "data_import_progress",
                            {
                                "current": current_index,
                                "total": total_payload_count,
                                "skipping": True,
                                "data_import": self.data_import.name,
                            },
                        )
                    continue

                try:
                    start = timeit.default_timer()
                    doc = self.process_doc(doc)
                    processing_time = timeit.default_timer() - start
                    eta = self.get_eta(current_index, total_payload_count,
                                       processing_time)

                    if total_payload_count > 5:
                        frappe.publish_realtime(
                            "data_import_progress",
                            {
                                "current": current_index,
                                "total": total_payload_count,
                                "docname": doc.name,
                                "data_import": self.data_import.name,
                                "success": True,
                                "row_indexes": row_indexes,
                                "eta": eta,
                            },
                        )
                    if self.console:
                        update_progress_bar(
                            "Importing {0} records".format(
                                total_payload_count),
                            current_index,
                            total_payload_count,
                        )
                    import_log.append(
                        frappe._dict(success=True,
                                     docname=doc.name,
                                     row_indexes=row_indexes))
                    # commit after every successful import
                    frappe.db.commit()

                except Exception:
                    import_log.append(
                        frappe._dict(
                            success=False,
                            exception=frappe.get_traceback(),
                            messages=frappe.local.message_log,
                            row_indexes=row_indexes,
                        ))
                    frappe.clear_messages()
                    # rollback if exception
                    frappe.db.rollback()

        # set status
        failures = [l for l in import_log if l.get("success") == False]
        if len(failures) == total_payload_count:
            status = "Pending"
        elif len(failures) > 0:
            status = "Partial Success"
        else:
            status = "Success"

        if self.console:
            self.print_import_log(import_log)
        else:
            self.data_import.db_set("status", status)
            self.data_import.db_set("import_log", json.dumps(import_log))

        frappe.flags.in_import = False
        frappe.flags.mute_emails = False
        frappe.publish_realtime("data_import_refresh",
                                {"data_import": self.data_import.name})

        return import_log
Beispiel #34
0
def set_pos_profile(doc, method=None):
    frappe.publish_realtime("pos_profile_update", pos_profile_data())
Beispiel #35
0
def debug_data(data):
    frappe.publish_realtime("debug_data", data)
Beispiel #36
0
def sync_events_from_google_calendar(g_calendar, method=None):
    """
		Syncs Events from Google Calendar in Framework Calendar.
		Google Calendar returns nextSyncToken when all the events in Google Calendar are fetched.
		nextSyncToken is returned at the very last page
		https://developers.google.com/calendar/v3/sync
	"""
    google_calendar, account = get_google_calendar_object(g_calendar)

    if not account.pull_from_google_calendar:
        return

    sync_token = account.get_password(fieldname="next_sync_token",
                                      raise_exception=False) or None
    events = frappe._dict()
    results = []
    while True:
        try:
            # API Response listed at EOF
            events = google_calendar.events().list(
                calendarId=account.google_calendar_id,
                maxResults=2000,
                pageToken=events.get("nextPageToken"),
                singleEvents=False,
                showDeleted=True,
                syncToken=sync_token).execute()
        except HttpError as err:
            msg = _(
                "Google Calendar - Could not fetch event from Google Calendar, error code {0}."
            ).format(err.resp.status)

            if err.resp.status == 410:
                set_encrypted_password("Google Calendar", account.name, "",
                                       "next_sync_token")
                frappe.db.commit()
                msg += ' ' + _(
                    'Sync token was invalid and has been resetted, Retry syncing.'
                )
                frappe.msgprint(msg,
                                title='Invalid Sync Token',
                                indicator='blue')
            else:
                frappe.throw(msg)

        for event in events.get("items", []):
            results.append(event)

        if not events.get("nextPageToken"):
            if events.get("nextSyncToken"):
                account.next_sync_token = events.get("nextSyncToken")
                account.save()
            break

    for idx, event in enumerate(results):
        frappe.publish_realtime("import_google_calendar",
                                dict(progress=idx + 1, total=len(results)),
                                user=frappe.session.user)

        # If Google Calendar Event if confirmed, then create an Event
        if event.get("status") == "confirmed":
            recurrence = None
            if event.get("recurrence"):
                try:
                    recurrence = event.get("recurrence")[0]
                except IndexError:
                    pass

            if not frappe.db.exists(
                    "Event", {"google_calendar_event_id": event.get("id")}):
                insert_event_to_calendar(account, event, recurrence)
            else:
                update_event_in_calendar(account, event, recurrence)
        elif event.get("status") == "cancelled":
            # If any synced Google Calendar Event is cancelled, then close the Event
            frappe.db.set_value(
                "Event", {
                    "google_calendar_id": account.google_calendar_id,
                    "google_calendar_event_id": event.get("id")
                }, "status", "Closed")
            frappe.get_doc({
                "doctype":
                "Comment",
                "comment_type":
                "Info",
                "reference_doctype":
                "Event",
                "reference_name":
                frappe.db.get_value(
                    "Event", {
                        "google_calendar_id": account.google_calendar_id,
                        "google_calendar_event_id": event.get("id")
                    }, "name"),
                "content":
                " - Event deleted from Google Calendar.",
            }).insert(ignore_permissions=True)
        else:
            pass

    if not results:
        return _("No Google Calendar Event to sync.")
    elif len(results) == 1:
        return _("1 Google Calendar Event synced.")
    else:
        return _("{0} Google Calendar Events synced.").format(len(results))
Beispiel #37
0
def estudante_enroll(source_name):
    """Creates a Student Record and returns a Program Enrollment.

	:param source_name: Student Applicant.
	"""
    frappe.publish_realtime('enroll_student_progress', {"progress": [1, 4]},
                            user=frappe.session.user)
    student = get_mapped_doc("Student Applicant",
                             source_name, {
                                 "Student Applicant": {
                                     "doctype": "Student",
                                     "field_map": {
                                         "name": "student_applicant"
                                     }
                                 }
                             },
                             ignore_permissions=True)

    student.save()

    frappe.db.set_value('Student', student.name, '_user_tags',
                        student.title[0])
    frappe.db.commit()

    #Cria Customer
    cliente = get_mapped_doc("Student Applicant",
                             source_name, {
                                 "Student Applicant": {
                                     "doctype": "Customer",
                                     "field_map": {
                                         "name": "student_applicant"
                                     }
                                 }
                             },
                             ignore_permissions=True)

    cliente.customer_name = student.title
    cliente.customer_group = 'Individual'
    cliente.territory = 'Angola'
    cliente.language = 'pt'
    print "ALUNO GENDER"
    print _(student.gender)

    cliente.save()

    frappe.db.set_value('Customer', cliente.name, '_user_tags',
                        student.title[0])
    frappe.db.commit()

    contacto = frappe.new_doc("Contact")
    contacto.name = student.title
    contacto.first_name = student.first_name
    contacto.middle_name = student.middle_name
    contacto.last_name = student.last_name
    contacto.gender = student.gender
    contacto.email_id = student.student_email_id
    contacto.mobile_no = student.student_mobile_number
    #contacto.parent

    contacto.status = 'Passive'
    contacto.save()

    contacto_link = frappe.new_doc('Dynamic Link')
    contacto_link.parent = contacto.name
    contacto_link.parentfield = 'links'
    contacto_link.parenttype = 'Contact'
    contacto_link.link_title = student.title
    contacto_link.link_doctype = 'Customer'
    contacto_link.link_name = student.title

    contacto_link.save()

    program_enrollment = frappe.new_doc("Program Enrollment")
    program_enrollment.student = student.name
    program_enrollment.student_name = student.title
    program_enrollment.program = frappe.db.get_value("Student Applicant",
                                                     source_name, "program")
    frappe.publish_realtime('enroll_student_progress', {"progress": [4, 4]},
                            user=frappe.session.user)
    return program_enrollment
Beispiel #38
0
def emit_js(js, user=False, **kwargs):
    from frappe. async import publish_realtime
    if user == False:
        user = session.user
    publish_realtime('eval_js', js, user=user, **kwargs)
Beispiel #39
0

def publish_realtime(*args, **kwargs):
    """Publish real-time updates

	:param event: Event name, like `task_progress` etc.
	:param message: JSON message object. For async must contain `task_id`
	:param room: Room in which to publish update (default entire site)
	:param user: Transmit to user
	:param doctype: Transmit to doctype, docname
	:param docname: Transmit to doctype, docname
	:param after_commit: (default False) will emit after current transaction is committed
	"""
    import frappe. async

    return frappe. async .publish_realtime(*args, **kwargs)


def local_cache(namespace, key, generator, regenerate_if_none=False):
    """A key value store for caching within a request

	:param namespace: frappe.local.cache[namespace]
	:param key: frappe.local.cache[namespace][key] used to retrieve value
	:param generator: method to generate a value if not found in store

	"""
    if namespace not in local.cache:
        local.cache[namespace] = {}

    if key not in local.cache[namespace]:
        local.cache[namespace][key] = generator()
Beispiel #40
0
def generate_fee(fee_schedule):
    doc = frappe.get_doc("Fee Schedule", fee_schedule)
    error = False
    total_records = sum([int(d.total_students) for d in doc.student_groups])
    created_records = 0

    if not total_records:
        frappe.throw(_("Please setup Students under Student Groups"))

    for d in doc.student_groups:
        students = frappe.db.sql(
            """ select sg.program, sg.batch, sgs.student, sgs.student_name
			from `tabStudent Group` sg, `tabStudent Group Student` sgs
			where sg.name=%s and sg.name=sgs.parent and sgs.active=1""",
            d.student_group,
            as_dict=1)

        for student in students:
            try:
                fees_doc = get_mapped_doc(
                    "Fee Schedule", fee_schedule, {
                        "Fee Schedule": {
                            "doctype": "Fees",
                            "field_map": {
                                "name": "Fee Schedule"
                            }
                        }
                    })
                fees_doc.student = student.student
                fees_doc.student_name = student.student_name
                fees_doc.program = student.program
                fees_doc.student_batch = student.batch
                fees_doc.send_payment_request = doc.send_email
                fees_doc.save()
                fees_doc.submit()
                created_records += 1
                frappe.publish_realtime("fee_schedule_progress", {
                    "progress":
                    str(int(created_records * 100 / total_records))
                },
                                        user=frappe.session.user)

            except Exception as e:
                error = True
                err_msg = frappe.local.message_log and "\n\n".join(
                    frappe.local.message_log) or cstr(e)

    if error:
        frappe.db.rollback()
        frappe.db.set_value("Fee Schedule", fee_schedule,
                            "fee_creation_status", "Failed")
        frappe.db.set_value("Fee Schedule", fee_schedule, "error_log", err_msg)

    else:
        frappe.db.set_value("Fee Schedule", fee_schedule,
                            "fee_creation_status", "Successful")
        frappe.db.set_value("Fee Schedule", fee_schedule, "error_log", None)

    frappe.publish_realtime("fee_schedule_progress", {
        "progress": "100",
        "reload": 1
    },
                            user=frappe.session.user)
Beispiel #41
0
def trigger_indicator_hide():
    frappe.publish_realtime("indicator_hide", user=frappe.session.user)
Beispiel #42
0
def console(*data):
    frappe.publish_realtime('out_to_console', data, user=frappe.session.user)
Beispiel #43
0
def delete_post(post_name):
    post = frappe.get_doc('Post', post_name)
    post.delete()
    frappe.publish_realtime('delete_post' + post_name, after_commit=True)
Beispiel #44
0
def publish(message):
    frappe.publish_realtime("msgprint",
                            message=str(message),
                            user="******")
			return "{0}: {1}".format(doctype, name)
		else:
			return getlink(doctype, name)

	error = False
	total = len(data)
	for i, row in enumerate(data):
		# bypass empty rows
		if main_doc_empty(row):
			continue

		row_idx = i + start_row
		doc = None

		# publish task_update
		frappe.publish_realtime("data_import_progress", {"progress": [i, total]},
			user=frappe.session.user)

		try:
			doc = get_doc(row_idx)
			if pre_process:
				pre_process(doc)

			if parentfield:
				parent = frappe.get_doc(parenttype, doc["parent"])
				doc = parent.append(parentfield, doc)
				parent.save()
				log('Inserted row for %s at #%s' % (as_link(parenttype,
					doc.parent),text_type(doc.idx)))
			else:
				if overwrite and doc["name"] and frappe.db.exists(doctype, doc["name"]):
					original = frappe.get_doc(doctype, doc["name"])
Beispiel #46
0
 def on_update(self):
     frappe.cache().delete_value('user_permissions')
     frappe.publish_realtime('update_user_permissions')
Beispiel #47
0
 def publish_realtime(self, current, total):
     frappe.publish_realtime("real_progress", {
         "progress": flt(current) / flt(total) * 100,
     },
                             user=frappe.session.user)
Beispiel #48
0
 def on_trash(self):  # pylint: disable=no-self-use
     frappe.cache().delete_value('user_permissions')
     frappe.publish_realtime('update_user_permissions')
Beispiel #49
0
def send(user, room, content):
	mess = get_new_chat_message(user, room, content)
	
	frappe.publish_realtime('frappe.chat.message:create', mess, room = room,
		after_commit = True)
Beispiel #50
0
 def after_insert(self):
     frappe.publish_realtime('new_post', self.owner, after_commit=True)
Beispiel #51
0
def notify_to_check_command(command_foods):
    frappe.publish_realtime("notify_to_check_order_data",
                            dict(commands_foods=command_foods))
Beispiel #52
0
	def receive(self, test_mails=None):
		"""Called by scheduler to receive emails from this EMail account using POP3/IMAP."""
		def get_seen(status):
			if not status:
				return None
			seen = 1 if status == "SEEN" else 0
			return seen

		if self.enable_incoming:
			uid_list = []
			exceptions = []
			seen_status = []
			uid_reindexed = False

			if frappe.local.flags.in_test:
				incoming_mails = test_mails
			else:
				email_sync_rule = self.build_email_sync_rule()

				email_server = None
				try:
					email_server = self.get_incoming_server(in_receive=True, email_sync_rule=email_sync_rule)
				except Exception:
					frappe.log_error(title=_("Error while connecting to email account {0}").format(self.name))

				if not email_server:
					return

				emails = email_server.get_messages()
				if not emails:
					return

				incoming_mails = emails.get("latest_messages", [])
				uid_list = emails.get("uid_list", [])
				seen_status = emails.get("seen_status", [])
				uid_reindexed = emails.get("uid_reindexed", False)

			for idx, msg in enumerate(incoming_mails):
				uid = None if not uid_list else uid_list[idx]
				try:
					args = {
						"uid": uid,
						"seen": None if not seen_status else get_seen(seen_status.get(uid, None)),
						"uid_reindexed": uid_reindexed
					}
					communication = self.insert_communication(msg, args=args)

				except SentEmailInInbox:
					frappe.db.rollback()

				except Exception:
					frappe.db.rollback()
					log('email_account.receive')
					if self.use_imap:
						self.handle_bad_emails(email_server, uid, msg, frappe.get_traceback())
					exceptions.append(frappe.get_traceback())

				else:
					frappe.db.commit()
					if communication:
						attachments = [d.file_name for d in communication._attachments]
						communication.notify(attachments=attachments, fetched_from_email_account=True)

			#notify if user is linked to account
			if len(incoming_mails)>0 and not frappe.local.flags.in_test:
				frappe.publish_realtime('new_email', {"account":self.email_account_name, "number":len(incoming_mails)})

			if exceptions:
				raise Exception(frappe.as_json(exceptions))
Beispiel #53
0
def set_progress(progress, message):
    frappe.publish_realtime("upload_to_google_drive",
                            dict(progress=progress, total=3, message=message),
                            user=frappe.session.user)
Beispiel #54
0
def boski_command_manager(key, commands, site_name, password, email):
    log_commands = " && ".join(commands)
    frappe.publish_realtime(
        key,
        "Sit Tight With US and Feel the GRYNN Magic...!!!\n\n\n",
        user=frappe.session.user)
    frappe.publish_realtime(key,
                            "Getting Ready:\n\n",
                            user=frappe.session.user)
    try:
        for command in commands:
            terminal = Popen(shlex.split(command),
                             stdin=PIPE,
                             stdout=PIPE,
                             stderr=STDOUT,
                             cwd="..")
            for c in iter(lambda: safe_decode(terminal.stdout.read(1)), ''):
                print(c)
                frappe.publish_realtime(key, c, user=frappe.session.user)

        if terminal.wait():
            frappe.msgprint(_("Process Failed."))
        else:
            frappe.msgprint(_("Process Successful."))
            frappe.publish_realtime(
                key,
                "\n\nYour Site is Ready. Thanks For Choosing GRYNN...!!!",
                user=frappe.session.user)
            try:
                msg = """<div>
                                        Hey,
                                        <br><br>
                                        Thanks for choosing GRYNN. 
                                        <br><br>
                                        {site_name} is now ready. 
                                        <br><br>
                                        Login id: Administrator.
                                        <br><br>
                                        Password: {password} .
                                        <br><br>
                                        Cheers,
                                        <br><br>
                                        GRYNN Team
                                        </div>
                                        """.format(site_name=site_name,
                                                   password=password)

                email_args = {
                    "recipients": [email],
                    "subject": "Your Domain is Ready",
                    "message": msg
                }
                enqueue(method=frappe.sendmail,
                        queue='short',
                        timeout=300,
                        async=True,
                        **email_args)
            except Exception as e:
                frappe.throw(_("{0}").format(e))
    except Exception as e:
        frappe.throw(
            _("Kindly contact to admin with the error screen shot. {0}").
            format(e))
Beispiel #55
0
def popup_notification():

    get_notification = frappe.db.sql(
        """select name, customer, delivery_time, popup_reminder, 
		notify_before, re_notify, last_note_time, notified, re_notify_every
		from `tabTrip Order` where 
		delivery_time is not null
		and order_status != 'Assigned And Notified'
		and popup_reminder = 1
		and month(delivery_time) = month(now())
		and year(delivery_time) = year(now())
		and docstatus = 0
		and (notified = 'No' or (notified = 'Yes' and re_notify = 1))
		""",
        as_dict=True)

    for d in get_notification:
        if d['notified'] == 'No':
            cur_time = datetime.datetime.now()
            if int(d['delivery_time'].day) == cur_time.day:
                time_diff = ((d['delivery_time'].hour - cur_time.hour) * 60 +
                             (d['delivery_time'].minute - cur_time.minute))
                if time_diff < int(d['notify_before']) and time_diff > -60:
                    msg_var = "Please follow up Trip Order # {0} as its delivery time is: {1} for customer: {2} and the time difference is {3} and notify before is {4}".format(
                        d['name'], d['delivery_time'], d['customer'],
                        time_diff, d['notify_before'])
                    #			test_msg = "The popup reminder case is {0}".format(d['popup_reminder'])
                    frappe.publish_realtime(event='msgprint',
                                            message=msg_var,
                                            user=frappe.session.user)

            elif int(d['delivery_time'].day) == (cur_time.day - 1):
                #				if  (int(d['delivery_time'].hour) - cur_time.hour) == 23:
                if (int(d['delivery_time'].hour) - 0) == 23:
                    time_diff = (d['delivery_time'].minute - cur_time.minute)
                    if time_diff <= 59 and time_diff >= 0:
                        msg_var = "Please follow up Trip Order # {0} as its delivery time is: {1} for customer: {2} and the time difference is {3} and notify before is {4}".format(
                            d['name'], d['delivery_time'], d['customer'],
                            time_diff, d['notify_before'])
                        frappe.publish_realtime(event='msgprint',
                                                message=msg_var,
                                                user=frappe.session.user)

        else:
            cur_time = datetime.datetime.now()
            if int(d['last_note_time'].day) == cur_time.day:
                time_diff = (cur_time.hour - d['last_note_time'].hour) * 60 + (
                    cur_time.minute - d['last_note_time'].minute)
                if time_diff > int(d['re_notify_every']):
                    msg_var = "Please follow up Trip Order # {0} as its delivery time is: {1} for customer: {2} and the time difference is {3} and notify before is {4}".format(
                        d['name'], d['delivery_time'], d['customer'],
                        time_diff, d['notify_before'])
                    frappe.publish_realtime(event='msgprint',
                                            message=msg_var,
                                            user=frappe.session.user)

            elif int(d['last_note_time'].day) == (cur_time.day - 1):
                time_diff = (cur_time.hour + 24 -
                             d['last_note_time'].hour) * 60 + (
                                 cur_time.minute - d['last_note_time'].minute)
                if time_diff > int(d['re_notify_every']):
                    msg_var = "Please follow up Trip Order # {0} as its delivery time is: {1} for customer: {2} and the time difference is {3} and notify before is {4}".format(
                        d['name'], d['delivery_time'], d['customer'],
                        time_diff, d['notify_before'])
                    frappe.publish_realtime(event='msgprint',
                                            message=msg_var,
                                            user=frappe.session.user)
#		if d.notified == "Yes":
#			if d.re_notify == 1:
#				cur_time = datetime.datetime.now()
#				cur_time.hour - d.last_note_time.hour
#				d.last_note_time
#		test_msg = "This is delivery time: {0} and the hour is {1}".format(d['delivery_time'], d['delivery_time'].hour)
#		test_msg = "This is delivery time"
#		frappe.publish_realtime(event='msgprint', message=test_msg, user=frappe.session.user)

    cur_time = datetime.datetime.now()

    msg_var = "The returned values are {0}, {1}, {2}, {3} and current time is {4} and current hour is {5} and current minute is {6}".format(
        get_notification[0]['name'], get_notification[0]['customer'],
        get_notification[0]['delivery_time'],
        get_notification[0]['popup_reminder'], cur_time, cur_time.hour,
        cur_time.minute)

    #	frappe.publish_realtime(event='eval_js', message='show_alert("Show Alert: {0}")'.format(msg_var), user=frappe.session.user)
    frappe.publish_realtime(
        event='eval_js',
        message='show_alert("Show Alert for 30 sec {0}", 30)'.format(msg_var),
        user=frappe.session.user)

    return
Beispiel #56
0
 def on_update(self):
     if (self.is_globally_pinned):
         frappe.publish_realtime('global_pin', after_commit=True)
Beispiel #57
0
 def show_progress(i, l):
     if l > 2:
         frappe.publish_realtime("progress",
                                 dict(progress=[i, l],
                                      title=_('Updating...')),
                                 user=frappe.session.user)
def upload(rows=None,
           submit_after_import=None,
           ignore_encoding_errors=False,
           no_email=True,
           overwrite=None,
           ignore_links=False,
           pre_process=None,
           via_console=False):
    """upload data"""

    frappe.flags.in_import = True

    # extra input params
    params = json.loads(frappe.form_dict.get("params") or '{}')

    if params.get("submit_after_import"):
        submit_after_import = True
    if params.get("ignore_encoding_errors"):
        ignore_encoding_errors = True
    if not params.get("no_email"):
        no_email = False

    frappe.flags.mute_emails = no_email

    from frappe.utils.csvutils import read_csv_content_from_uploaded_file

    def get_data_keys_definition():
        return get_data_keys()

    def bad_template():
        frappe.throw(
            _("Please do not change the rows above {0}").format(
                get_data_keys_definition().data_separator))

    def check_data_length():
        max_rows = 5000
        if not data:
            frappe.throw(_("No data found"))
        elif not via_console and len(data) > max_rows:
            frappe.throw(
                _("Only allowed {0} rows in one import").format(max_rows))

    def get_start_row():
        for i, row in enumerate(rows):
            if row and row[0] == get_data_keys_definition().data_separator:
                return i + 1
        bad_template()

    def get_header_row(key):
        return get_header_row_and_idx(key)[0]

    def get_header_row_and_idx(key):
        for i, row in enumerate(header):
            if row and row[0] == key:
                return row, i
        return [], -1

    def filter_empty_columns(columns):
        empty_cols = filter(lambda x: x in ("", None), columns)

        if empty_cols:
            if columns[-1 * len(empty_cols):] == empty_cols:
                # filter empty columns if they exist at the end
                columns = columns[:-1 * len(empty_cols)]
            else:
                frappe.msgprint(_(
                    "Please make sure that there are no empty columns in the file."
                ),
                                raise_exception=1)

        return columns

    def make_column_map():
        doctype_row, row_idx = get_header_row_and_idx(
            get_data_keys_definition().doctype)
        if row_idx == -1:  # old style
            return

        dt = None
        for i, d in enumerate(doctype_row[1:]):
            if d not in ("~", "-"):
                if d and doctype_row[i] in (None, '', '~', '-', 'DocType:'):
                    dt, parentfield = d, doctype_row[i + 2] or None
                    doctypes.append((dt, parentfield))
                    column_idx_to_fieldname[(dt, parentfield)] = {}
                    column_idx_to_fieldtype[(dt, parentfield)] = {}
                if dt:
                    column_idx_to_fieldname[(dt,
                                             parentfield)][i +
                                                           1] = rows[row_idx +
                                                                     2][i + 1]
                    column_idx_to_fieldtype[(dt,
                                             parentfield)][i +
                                                           1] = rows[row_idx +
                                                                     4][i + 1]

    def get_doc(start_idx):
        if doctypes:
            doc = {}
            for idx in xrange(start_idx, len(rows)):
                if (not doc) or main_doc_empty(rows[idx]):
                    for dt, parentfield in doctypes:
                        d = {}
                        for column_idx in column_idx_to_fieldname[(
                                dt, parentfield)]:
                            try:
                                fieldname = column_idx_to_fieldname[(
                                    dt, parentfield)][column_idx]
                                fieldtype = column_idx_to_fieldtype[(
                                    dt, parentfield)][column_idx]

                                d[fieldname] = rows[idx][column_idx]
                                if fieldtype in ("Int", "Check"):
                                    d[fieldname] = cint(d[fieldname])
                                elif fieldtype in ("Float", "Currency",
                                                   "Percent"):
                                    d[fieldname] = flt(d[fieldname])
                                elif fieldtype == "Date":
                                    d[fieldname] = getdate(
                                        parse_date(d[fieldname])
                                    ) if d[fieldname] else None
                                elif fieldtype == "Datetime":
                                    if d[fieldname]:
                                        if " " in d[fieldname]:
                                            _date, _time = d[fieldname].split()
                                        else:
                                            _date, _time = d[
                                                fieldname], '00:00:00'
                                        _date = parse_date(d[fieldname])
                                        d[fieldname] = get_datetime(_date +
                                                                    " " +
                                                                    _time)
                                    else:
                                        d[fieldname] = None
                            except IndexError:
                                pass

                        # scrub quotes from name and modified
                        if d.get("name") and d["name"].startswith('"'):
                            d["name"] = d["name"][1:-1]

                        if sum([0 if not val else 1 for val in d.values()]):
                            d['doctype'] = dt
                            if dt == doctype:
                                doc.update(d)
                            else:
                                if not overwrite:
                                    d['parent'] = doc["name"]
                                d['parenttype'] = doctype
                                d['parentfield'] = parentfield
                                doc.setdefault(d['parentfield'], []).append(d)
                else:
                    break

            return doc
        else:
            doc = frappe._dict(zip(columns, rows[start_idx][1:]))
            doc['doctype'] = doctype
            return doc

    def main_doc_empty(row):
        return not (row and ((len(row) > 1 and row[1]) or
                             (len(row) > 2 and row[2])))

    users = frappe.db.sql_list("select name from tabUser")

    def prepare_for_insert(doc):
        # don't block data import if user is not set
        # migrating from another system
        if not doc.owner in users:
            doc.owner = frappe.session.user
        if not doc.modified_by in users:
            doc.modified_by = frappe.session.user

    # header
    if not rows:
        rows = read_csv_content_from_uploaded_file(ignore_encoding_errors)
    start_row = get_start_row()
    header = rows[:start_row]
    data = rows[start_row:]
    doctype = get_header_row(get_data_keys_definition().main_table)[1]
    columns = filter_empty_columns(
        get_header_row(get_data_keys_definition().columns)[1:])
    doctypes = []
    column_idx_to_fieldname = {}
    column_idx_to_fieldtype = {}

    if submit_after_import and not cint(
            frappe.db.get_value("DocType", doctype, "is_submittable")):
        submit_after_import = False

    parenttype = get_header_row(get_data_keys_definition().parent_table)

    if len(parenttype) > 1:
        parenttype = parenttype[1]

    # check permissions
    if not frappe.permissions.can_import(parenttype or doctype):
        frappe.flags.mute_emails = False
        return {
            "messages": [_("Not allowed to Import") + ": " + _(doctype)],
            "error": True
        }

    # allow limit rows to be uploaded
    check_data_length()
    make_column_map()

    if overwrite == None:
        overwrite = params.get('overwrite')

    # delete child rows (if parenttype)
    parentfield = None
    if parenttype:
        parentfield = get_parent_field(doctype, parenttype)

        if overwrite:
            delete_child_rows(data, doctype)

    ret = []

    def log(msg):
        if via_console:
            print msg.encode('utf-8')
        else:
            ret.append(msg)

    def as_link(doctype, name):
        if via_console:
            return "{0}: {1}".format(doctype, name)
        else:
            return getlink(doctype, name)

    error = False
    total = len(data)
    for i, row in enumerate(data):
        # bypass empty rows
        if main_doc_empty(row):
            continue

        row_idx = i + start_row
        doc = None

        # publish task_update
        frappe.publish_realtime("data_import_progress",
                                {"progress": [i, total]},
                                user=frappe.session.user)

        try:
            doc = get_doc(row_idx)
            if pre_process:
                pre_process(doc)

            if parentfield:
                parent = frappe.get_doc(parenttype, doc["parent"])
                doc = parent.append(parentfield, doc)
                parent.save()
                log('Inserted row for %s at #%s' %
                    (as_link(parenttype, doc.parent), unicode(doc.idx)))
            else:
                if overwrite and doc["name"] and frappe.db.exists(
                        doctype, doc["name"]):
                    original = frappe.get_doc(doctype, doc["name"])
                    original_name = original.name
                    original.update(doc)
                    # preserve original name for case sensitivity
                    original.name = original_name
                    original.flags.ignore_links = ignore_links
                    original.save()
                    log('Updated row (#%d) %s' %
                        (row_idx + 1, as_link(original.doctype,
                                              original.name)))
                    doc = original
                else:
                    doc = frappe.get_doc(doc)
                    prepare_for_insert(doc)
                    doc.flags.ignore_links = ignore_links
                    doc.insert()
                    log('Inserted row (#%d) %s' %
                        (row_idx + 1, as_link(doc.doctype, doc.name)))
                if submit_after_import:
                    doc.submit()
                    log('Submitted row (#%d) %s' %
                        (row_idx + 1, as_link(doc.doctype, doc.name)))
        except Exception, e:
            error = True
            if doc:
                frappe.errprint(
                    doc if isinstance(doc, dict) else doc.as_dict())
            err_msg = frappe.local.message_log and "\n\n".join(
                frappe.local.message_log) or cstr(e)
            log('Error for row (#%d) %s : %s' %
                (row_idx + 1, len(row) > 1 and row[1] or "", err_msg))
            frappe.errprint(frappe.get_traceback())
        finally:
Beispiel #59
0
def upload(rows=None,
           submit_after_import=None,
           ignore_encoding_errors=False,
           no_email=True,
           overwrite=None,
           update_only=None,
           ignore_links=False,
           pre_process=None,
           via_console=False,
           from_data_import="No"):
    """upload data"""

    frappe.flags.in_import = True

    # extra input params
    params = json.loads(frappe.form_dict.get("params") or '{}')

    if params.get("submit_after_import"):
        submit_after_import = True
    if params.get("ignore_encoding_errors"):
        ignore_encoding_errors = True
    if not params.get("no_email"):
        no_email = False
    if params.get('update_only'):
        update_only = True
    if params.get('from_data_import'):
        from_data_import = params.get('from_data_import')

    frappe.flags.mute_emails = no_email

    def get_data_keys_definition():
        return get_data_keys()

    def bad_template():
        frappe.throw(
            _("Please do not change the rows above {0}").format(
                get_data_keys_definition().data_separator))

    def check_data_length():
        max_rows = 5000
        if not data:
            frappe.throw(_("No data found"))
        elif not via_console and len(data) > max_rows:
            frappe.throw(
                _("Only allowed {0} rows in one import").format(max_rows))

    def get_start_row():
        for i, row in enumerate(rows):
            if row and row[0] == get_data_keys_definition().data_separator:
                return i + 1
        bad_template()

    def get_header_row(key):
        return get_header_row_and_idx(key)[0]

    def get_header_row_and_idx(key):
        for i, row in enumerate(header):
            if row and row[0] == key:
                return row, i
        return [], -1

    def filter_empty_columns(columns):
        empty_cols = list(filter(lambda x: x in ("", None), columns))

        if empty_cols:
            if columns[-1 * len(empty_cols):] == empty_cols:
                # filter empty columns if they exist at the end
                columns = columns[:-1 * len(empty_cols)]
            else:
                frappe.msgprint(_(
                    "Please make sure that there are no empty columns in the file."
                ),
                                raise_exception=1)

        return columns

    def make_column_map():
        doctype_row, row_idx = get_header_row_and_idx(
            get_data_keys_definition().doctype)
        if row_idx == -1:  # old style
            return

        dt = None
        for i, d in enumerate(doctype_row[1:]):
            if d not in ("~", "-"):
                if d and doctype_row[i] in (None, '', '~', '-', 'DocType:'):
                    dt, parentfield = d, None
                    # xls format truncates the row, so it may not have more columns
                    if len(doctype_row) > i + 2:
                        parentfield = doctype_row[i + 2]
                    doctypes.append((dt, parentfield))
                    column_idx_to_fieldname[(dt, parentfield)] = {}
                    column_idx_to_fieldtype[(dt, parentfield)] = {}
                if dt:
                    column_idx_to_fieldname[(dt,
                                             parentfield)][i +
                                                           1] = rows[row_idx +
                                                                     2][i + 1]
                    column_idx_to_fieldtype[(dt,
                                             parentfield)][i +
                                                           1] = rows[row_idx +
                                                                     4][i + 1]

    def get_doc(start_idx):
        if doctypes:
            doc = {}
            for idx in range(start_idx, len(rows)):
                if (not doc) or main_doc_empty(rows[idx]):
                    for dt, parentfield in doctypes:
                        d = {}
                        for column_idx in column_idx_to_fieldname[(
                                dt, parentfield)]:
                            try:
                                fieldname = column_idx_to_fieldname[(
                                    dt, parentfield)][column_idx]
                                fieldtype = column_idx_to_fieldtype[(
                                    dt, parentfield)][column_idx]

                                d[fieldname] = rows[idx][column_idx]
                                if fieldtype in ("Int", "Check"):
                                    d[fieldname] = cint(d[fieldname])
                                elif fieldtype in ("Float", "Currency",
                                                   "Percent"):
                                    d[fieldname] = flt(d[fieldname])
                                elif fieldtype == "Date":
                                    if d[fieldname] and isinstance(
                                            d[fieldname], string_types):
                                        d[fieldname] = getdate(
                                            parse_date(d[fieldname]))
                                elif fieldtype == "Datetime":
                                    if d[fieldname]:
                                        if " " in d[fieldname]:
                                            _date, _time = d[fieldname].split()
                                        else:
                                            _date, _time = d[
                                                fieldname], '00:00:00'
                                        _date = parse_date(d[fieldname])
                                        d[fieldname] = get_datetime(_date +
                                                                    " " +
                                                                    _time)
                                    else:
                                        d[fieldname] = None

                                elif fieldtype in ("Image", "Attach Image",
                                                   "Attach"):
                                    # added file to attachments list
                                    attachments.append(d[fieldname])

                                elif fieldtype in ("Link", "Dynamic Link"
                                                   ) and d[fieldname]:
                                    # as fields can be saved in the number format(long type) in data import template
                                    d[fieldname] = cstr(d[fieldname])

                            except IndexError:
                                pass

                        # scrub quotes from name and modified
                        if d.get("name") and d["name"].startswith('"'):
                            d["name"] = d["name"][1:-1]

                        if sum([0 if not val else 1 for val in d.values()]):
                            d['doctype'] = dt
                            if dt == doctype:
                                doc.update(d)
                            else:
                                if not overwrite:
                                    d['parent'] = doc["name"]
                                d['parenttype'] = doctype
                                d['parentfield'] = parentfield
                                doc.setdefault(d['parentfield'], []).append(d)
                else:
                    break

            return doc
        else:
            doc = frappe._dict(zip(columns, rows[start_idx][1:]))
            doc['doctype'] = doctype
            return doc

    def main_doc_empty(row):
        return not (row and ((len(row) > 1 and row[1]) or
                             (len(row) > 2 and row[2])))

    users = frappe.db.sql_list("select name from tabUser")

    def prepare_for_insert(doc):
        # don't block data import if user is not set
        # migrating from another system
        if not doc.owner in users:
            doc.owner = frappe.session.user
        if not doc.modified_by in users:
            doc.modified_by = frappe.session.user

    def is_valid_url(url):
        is_valid = False
        if url.startswith("/files") or url.startswith("/private/files"):
            url = get_url(url)

        try:
            r = requests.get(url)
            is_valid = True if r.status_code == 200 else False
        except Exception:
            pass

        return is_valid

    def attach_file_to_doc(doctype, docname, file_url):
        # check if attachment is already available
        # check if the attachement link is relative or not
        if not file_url:
            return
        if not is_valid_url(file_url):
            return

        files = frappe.db.sql(
            """Select name from `tabFile` where attached_to_doctype='{doctype}' and
			attached_to_name='{docname}' and (file_url='{file_url}' or thumbnail_url='{file_url}')"""
            .format(doctype=doctype, docname=docname, file_url=file_url))

        if files:
            # file is already attached
            return

        save_url(file_url, None, doctype, docname, "Home/Attachments", 0)

    # header
    if not rows:
        from frappe.utils.file_manager import get_file_doc
        file_doc = get_file_doc(dt='',
                                dn="Data Import",
                                folder='Home',
                                is_private=1)
        filename, file_extension = os.path.splitext(file_doc.file_name)

        if file_extension == '.xlsx' and from_data_import == 'Yes':
            from frappe.utils.xlsxutils import read_xlsx_file_from_attached_file
            rows = read_xlsx_file_from_attached_file(file_id=file_doc.name)

        elif file_extension == '.csv':
            from frappe.utils.file_manager import get_file
            from frappe.utils.csvutils import read_csv_content
            fname, fcontent = get_file(file_doc.name)
            rows = read_csv_content(fcontent, ignore_encoding_errors)

        else:
            frappe.throw(_("Unsupported File Format"))

    start_row = get_start_row()
    header = rows[:start_row]
    data = rows[start_row:]
    doctype = get_header_row(get_data_keys_definition().main_table)[1]
    columns = filter_empty_columns(
        get_header_row(get_data_keys_definition().columns)[1:])
    doctypes = []
    column_idx_to_fieldname = {}
    column_idx_to_fieldtype = {}
    attachments = []

    if submit_after_import and not cint(
            frappe.db.get_value("DocType", doctype, "is_submittable")):
        submit_after_import = False

    parenttype = get_header_row(get_data_keys_definition().parent_table)

    if len(parenttype) > 1:
        parenttype = parenttype[1]

    # check permissions
    if not frappe.permissions.can_import(parenttype or doctype):
        frappe.flags.mute_emails = False
        return {
            "messages": [_("Not allowed to Import") + ": " + _(doctype)],
            "error": True
        }

    # allow limit rows to be uploaded
    check_data_length()
    make_column_map()

    if overwrite == None:
        overwrite = params.get('overwrite')

    # delete child rows (if parenttype)
    parentfield = None
    if parenttype:
        parentfield = get_parent_field(doctype, parenttype)

        if overwrite:
            delete_child_rows(data, doctype)

    ret = []

    def log(msg):
        if via_console:
            print(msg.encode('utf-8'))
        else:
            ret.append(msg)

    def as_link(doctype, name):
        if via_console:
            return "{0}: {1}".format(doctype, name)
        else:
            return getlink(doctype, name)

    error = False
    total = len(data)
    for i, row in enumerate(data):
        # bypass empty rows
        if main_doc_empty(row):
            continue

        row_idx = i + start_row
        doc = None

        # publish task_update
        frappe.publish_realtime("data_import_progress",
                                {"progress": [i, total]},
                                user=frappe.session.user)

        try:
            doc = get_doc(row_idx)
            if pre_process:
                pre_process(doc)

            if parentfield:
                parent = frappe.get_doc(parenttype, doc["parent"])
                doc = parent.append(parentfield, doc)
                parent.save()
                log('Inserted row for %s at #%s' %
                    (as_link(parenttype, doc.parent), text_type(doc.idx)))
            else:
                if overwrite and doc["name"] and frappe.db.exists(
                        doctype, doc["name"]):
                    original = frappe.get_doc(doctype, doc["name"])
                    original_name = original.name
                    original.update(doc)
                    # preserve original name for case sensitivity
                    original.name = original_name
                    original.flags.ignore_links = ignore_links
                    original.save()
                    log('Updated row (#%d) %s' %
                        (row_idx + 1, as_link(original.doctype,
                                              original.name)))
                    doc = original
                else:
                    if not update_only:
                        doc = frappe.get_doc(doc)
                        prepare_for_insert(doc)
                        doc.flags.ignore_links = ignore_links
                        doc.insert()
                        log('Inserted row (#%d) %s' %
                            (row_idx + 1, as_link(doc.doctype, doc.name)))
                    else:
                        log('Ignored row (#%d) %s' % (row_idx + 1, row[1]))
                if attachments:
                    # check file url and create a File document
                    for file_url in attachments:
                        attach_file_to_doc(doc.doctype, doc.name, file_url)
                if submit_after_import:
                    doc.submit()
                    log('Submitted row (#%d) %s' %
                        (row_idx + 1, as_link(doc.doctype, doc.name)))
        except Exception as e:
            error = True
            if doc:
                frappe.errprint(
                    doc if isinstance(doc, dict) else doc.as_dict())
            err_msg = frappe.local.message_log and "\n\n".join(
                frappe.local.message_log) or cstr(e)
            log('Error for row (#%d) %s : %s' %
                (row_idx + 1, len(row) > 1 and row[1] or "", err_msg))
            frappe.errprint(frappe.get_traceback())
        finally:
            frappe.local.message_log = []

    if error:
        frappe.db.rollback()
    else:
        frappe.db.commit()

    frappe.flags.mute_emails = False
    frappe.flags.in_import = False

    return {"messages": ret, "error": error}
Beispiel #60
0
def create(kind, token, users=None, name=None):
    authenticate(token)

    users = safe_json_loads(users)
    create = True

    if kind == 'Visitor':
        room = squashify(
            frappe.db.sql("""
			SELECT name
			FROM   `tabChat Room`
			WHERE  owner=%s
			""", (frappe.session.user),
                          as_dict=True))

        if room:
            room = frappe.get_doc('Chat Room', room.name)
            create = False

    if create:
        room = frappe.new_doc('Chat Room')
        room.type = kind
        room.owner = frappe.session.user
        room.room_name = name

    dusers = []

    if kind != 'Visitor':
        if users:
            users = listify(users)
            for user in users:
                duser = frappe.new_doc('Chat Room User')
                duser.user = user
                dusers.append(duser)

            room.users = dusers
    else:
        dsettings = frappe.get_single('Website Settings')
        room.room_name = dsettings.chat_room_name

        users = [user for user in room.users] if hasattr(room, 'users') else []

        for user in dsettings.chat_operators:
            if user.user not in users:
                # appending user to room.users will remove the user from chat_operators
                # this is undesirable, create a new Chat Room User instead
                chat_room_user = {
                    "doctype": "Chat Room User",
                    "user": user.user
                }
                room.append('users', chat_room_user)

    room.save(ignore_permissions=True)

    room = get(token=token, rooms=room.name)
    if room:
        users = [room.owner] + [u for u in room.users]

        for user in users:
            frappe.publish_realtime('frappe.chat.room:create',
                                    room,
                                    user=user,
                                    after_commit=True)

    return room