Пример #1
1
def validate_expense_against_budget(args):
	args = frappe._dict(args)
	if frappe.db.get_value("Account", {"name": args.account, "root_type": "Expense"}):
			budget = frappe.db.sql("""
				select bd.budget_allocated, cc.distribution_id
				from `tabCost Center` cc, `tabBudget Detail` bd
				where cc.name=bd.parent and cc.name=%s and account=%s and bd.fiscal_year=%s
			""", (args.cost_center, args.account, args.fiscal_year), as_dict=True)

			if budget and budget[0].budget_allocated:
				yearly_action, monthly_action = frappe.db.get_value("Company", args.company,
					["yearly_bgt_flag", "monthly_bgt_flag"])
				action_for = action = ""

				if monthly_action in ["Stop", "Warn"]:
					budget_amount = get_allocated_budget(budget[0].distribution_id,
						args.posting_date, args.fiscal_year, budget[0].budget_allocated)

					args["month_end_date"] = frappe.db.sql("select LAST_DAY(%s)",
						args.posting_date)[0][0]
					action_for, action = _("Monthly"), monthly_action

				elif yearly_action in ["Stop", "Warn"]:
					budget_amount = budget[0].budget_allocated
					action_for, action = _("Annual"), yearly_action

				if action_for:
					actual_expense = get_actual_expense(args)
					if actual_expense > budget_amount:
						frappe.msgprint(_("{0} budget for Account {1} against Cost Center {2} will exceed by {3}").format(
							_(action_for), args.account, args.cost_center, cstr(actual_expense - budget_amount)))
						if action=="Stop":
							raise BudgetError
Пример #2
0
	def validate_mandatory_fields(self):
		if self.group_based_on == "Course" and not self.course:
			frappe.throw(_("Please select Course"))
		if self.group_based_on == "Course" and (not self.program and self.batch):
			frappe.throw(_("Please select Program"))
		if self.group_based_on == "Batch" and not self.program:
			frappe.throw(_("Please select Program"))
Пример #3
0
		def _get_message(url=False):
			if url:
				name = get_url_to_form(self.doctype, self.name)
			else:
				name = self.name

			return (_("Leave Application") + ": %s - %s") % (name, _(status))
Пример #4
0
def validate_filters(filters):

	if not filters.fiscal_year:
		frappe.throw(_("Fiscal Year {0} is required").format(filters.fiscal_year))

	fiscal_year = frappe.db.get_value("Fiscal Year", filters.fiscal_year, ["year_start_date", "year_end_date"], as_dict=True)
	if not fiscal_year:
		frappe.throw(_("Fiscal Year {0} does not exist").format(filters.fiscal_year))
	else:
		filters.year_start_date = getdate(fiscal_year.year_start_date)
		filters.year_end_date = getdate(fiscal_year.year_end_date)

	if not filters.from_date:
		filters.from_date = filters.year_start_date

	if not filters.to_date:
		filters.to_date = filters.year_end_date

	filters.from_date = getdate(filters.from_date)
	filters.to_date = getdate(filters.to_date)

	if filters.from_date > filters.to_date:
		frappe.throw(_("From Date cannot be greater than To Date"))

	if (filters.from_date < filters.year_start_date) or (filters.from_date > filters.year_end_date):
		frappe.msgprint(_("From Date should be within the Fiscal Year. Assuming From Date = {0}")\
			.format(formatdate(filters.year_start_date)))

		filters.from_date = filters.year_start_date

	if (filters.to_date < filters.year_start_date) or (filters.to_date > filters.year_end_date):
		frappe.msgprint(_("To Date should be within the Fiscal Year. Assuming To Date = {0}")\
			.format(formatdate(filters.year_end_date)))
		filters.to_date = filters.year_end_date
Пример #5
0
	def validate_website_image(self):
		"""Validate if the website image is a public file"""
		auto_set_website_image = False
		if not self.website_image and self.image:
			auto_set_website_image = True
			self.website_image = self.image

		if not self.website_image:
			return

		# find if website image url exists as public
		file_doc = frappe.get_all("File", filters={
			"file_url": self.website_image
		}, fields=["name", "is_private"], order_by="is_private asc", limit_page_length=1)


		if file_doc:
			file_doc = file_doc[0]

		if not file_doc:
			if not auto_set_website_image:
				frappe.msgprint(_("Website Image {0} attached to Item {1} cannot be found")
					.format(self.website_image, self.name))

			self.website_image = None

		elif file_doc.is_private:
			if not auto_set_website_image:
				frappe.msgprint(_("Website Image should be a public file or website URL"))

			self.website_image = None
Пример #6
0
	def connect(self):
		"""Connect to **Email Account**."""
		try:
			if cint(self.settings.use_ssl):
				self.pop = Timed_POP3_SSL(self.settings.host, timeout=frappe.conf.get("pop_timeout"))
			else:
				self.pop = Timed_POP3(self.settings.host, timeout=frappe.conf.get("pop_timeout"))

			self.pop.user(self.settings.username)
			self.pop.pass_(self.settings.password)

			# connection established!
			return True

		except _socket.error:
			# Invalid mail server -- due to refusing connection
			frappe.msgprint(_('Invalid Mail Server. Please rectify and try again.'))
			raise

		except poplib.error_proto, e:
			if self.is_temporary_system_problem(e):
				return False

			else:
				frappe.msgprint(_('Invalid User Name or Support Password. Please rectify and try again.'))
				raise
Пример #7
0
def validate_fiscal_year(date, fiscal_year, label=_("Date"), doc=None):
	years = [f[0] for f in get_fiscal_years(date, label=label)]
	if fiscal_year not in years:
		if doc:
			doc.fiscal_year = years[0]
		else:
			throw(_("{0} '{1}' not in Fiscal Year {2}").format(label, formatdate(date), fiscal_year))
Пример #8
0
	def validate_item(self):
		stock_items = self.get_stock_items()
		serialized_items = self.get_serialized_items()
		for item in self.get("items"):
			if item.item_code not in stock_items:
				frappe.throw(_("{0} is not a stock Item").format(item.item_code))

			item_details = self.get_item_details(frappe._dict({"item_code": item.item_code,
				"company": self.company, "project_name": self.project_name}))

			for f in ("uom", "stock_uom", "description", "item_name", "expense_account",
				"cost_center", "conversion_factor"):
					if f not in ["expense_account", "cost_center"] or not item.get(f):
						item.set(f, item_details.get(f))

			if self.difference_account:
				item.expense_account = self.difference_account

			if not item.transfer_qty:
				item.transfer_qty = item.qty * item.conversion_factor

			if (self.purpose in ("Material Transfer", "Sales Return", "Purchase Return", "Material Transfer for Manufacture")
				and not item.serial_no
				and item.item_code in serialized_items):
				frappe.throw(_("Row #{0}: Please specify Serial No for Item {1}").format(item.idx, item.item_code),
					frappe.MandatoryError)
Пример #9
0
def bulk_rename(doctype, rows=None, via_console = False):
	"""Bulk rename documents

	:param doctype: DocType to be renamed
	:param rows: list of documents as `((oldname, newname), ..)`"""
	if not rows:
		frappe.throw(_("Please select a valid csv file with data"))

	if not via_console:
		max_rows = 500
		if len(rows) > max_rows:
			frappe.throw(_("Maximum {0} rows allowed").format(max_rows))

	rename_log = []
	for row in rows:
		# if row has some content
		if len(row) > 1 and row[0] and row[1]:
			try:
				if rename_doc(doctype, row[0], row[1]):
					msg = _("Successful: {0} to {1}").format(row[0], row[1])
					frappe.db.commit()
				else:
					msg = _("Ignored: {0} to {1}").format(row[0], row[1])
			except Exception, e:
				msg = _("** Failed: {0} to {1}: {2}").format(row[0], row[1], repr(e))
				frappe.db.rollback()

			if via_console:
				print msg
			else:
				rename_log.append(msg)
Пример #10
0
	def validate_fieldtype_change(self, df, old_value, new_value):
		for allowed_changes in self.allowed_fieldtype_change:
			if ((old_value in allowed_changes and new_value in allowed_changes)
				or (old_value not in allowed_changes and new_value not in allowed_changes)):
				continue
			else:
				frappe.throw(_("Fieldtype must be one of {0} in row {1}").format(", ".join([_(fieldtype) for fieldtype in allowed_changes]), df.idx))
def get_data():
	return {
		'fieldname': 'purchase_invoice',
		'non_standard_fieldnames': {
			'Journal Entry': 'reference_name',
			'Payment Entry': 'reference_name',
			'Payment Request': 'reference_name',
			'Landed Cost Voucher': 'receipt_document',
			'Purchase Invoice': 'return_against',
			'Subscription': 'reference_document'
		},
		'internal_links': {
			'Purchase Order': ['items', 'purchase_order'],
			'Purchase Receipt': ['items', 'purchase_receipt'],
		},
		'transactions': [
			{
				'label': _('Payment'),
				'items': ['Payment Entry', 'Payment Request', 'Journal Entry']
			},
			{
				'label': _('Reference'),
				'items': ['Purchase Order', 'Purchase Receipt', 'Asset', 'Landed Cost Voucher']
			},
			{
				'label': _('Returns'),
				'items': ['Purchase Invoice']
			},
			{
				'label': _('Subscription'),
				'items': ['Subscription']
			},
		]
	}
Пример #12
0
	def validate(self):
		"""Validate email id and check POP3 and SMTP connections is enabled."""
		if self.email_id:
			validate_email_add(self.email_id, True)

		if self.login_id_is_different:
			if not self.login_id:
				frappe.throw(_("Login Id is required"))
		else:
			self.login_id = None

		if frappe.local.flags.in_patch or frappe.local.flags.in_test:
			return

		if self.enable_incoming and not self.append_to:
			frappe.throw(_("Append To is mandatory for incoming mails"))

		if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
			if self.enable_incoming:
				self.get_pop3()

			if self.enable_outgoing:
				self.check_smtp()

		if self.notify_if_unreplied:
			if not self.send_notification_to:
				frappe.throw(_("{0} is mandatory").format(self.meta.get_label("send_notification_to")))
			for e in self.get_unreplied_notification_emails():
				validate_email_add(e, True)

		if self.enable_incoming and self.append_to:
			valid_doctypes = [d[0] for d in get_append_to()]
			if self.append_to not in valid_doctypes:
				frappe.throw(_("Append To can be one of {0}").format(comma_or(valid_doctypes)))
Пример #13
0
def get_data(filters):
	conditions, filters = get_conditions(filters)

        data = frappe.db.sql("""
                select t1.employee, t3.employee_name, t1.designation, t3.passport_number,
                        sum(case when t2.salary_component = 'Basic Pay' then ifnull(t2.amount,0) else 0 end) as basicpay,
                        t3.nppf_number,
                        sum(case when t2.salary_component = 'PF' then ifnull(t2.amount,0) else 0 end) as employeepf,
                        sum(case when t2.salary_component = 'PF' then ifnull(t2.amount,0) else 0 end) as employerpf,
                        sum(case when t2.salary_component = 'PF' then ifnull(t2.amount,0)*2 else 0 end) as total,
                        t1.company, t1.branch, t1.department, t1.division, t1.section,
                        t1.fiscal_year, t1.month
                from `tabSalary Slip` t1, `tabSalary Detail` t2, `tabEmployee` t3
                where t1.docstatus = 1 %s
                and t3.employee = t1.employee
                and t2.parent = t1.name
                and t2.salary_component in ('Basic Pay','PF')
                group by t1.employee, t3.employee_name, t1.designation, t3.passport_number,
                        t3.nppf_number, t1.company, t1.branch, t1.department, t1.division, t1.section,
                        t1.fiscal_year, t1.month
                """ % conditions, filters)
		
	if not data:
		msgprint(_("No Data Found for month: ") + cstr(filters.get("month")) + 
			_(" and year: ") + cstr(filters.get("fiscal_year")), raise_exception=1)
	
	return data
Пример #14
0
def get_conditions(filters):
	conditions = ""
	if not filters.get("from_date"):
		frappe.throw(_("'From Date' is required"))

	if filters.get("to_date"):
		conditions += " and sle.posting_date <= '%s'" % frappe.db.escape(filters.get("to_date"))
	else:
		frappe.throw(_("'To Date' is required"))

	if filters.get("item_group"):		
		ig_details = frappe.db.get_value("Item Group", filters.get("item_group"), 
			["lft", "rgt"], as_dict=1)
			
		if ig_details:
			conditions += """ 
				and exists (select name from `tabItem Group` ig 
				where ig.lft >= %s and ig.rgt <= %s and item.item_group = ig.name)
			""" % (ig_details.lft, ig_details.rgt)
		
	if filters.get("item_code"):
		conditions += " and sle.item_code = '%s'" % frappe.db.escape(filters.get("item_code"), percent=False)

	if filters.get("warehouse"):
		warehouse_details = frappe.db.get_value("Warehouse", filters.get("warehouse"), ["lft", "rgt"], as_dict=1)
		if warehouse_details:
			conditions += " and exists (select name from `tabWarehouse` wh \
				where wh.lft >= %s and wh.rgt <= %s and sle.warehouse = wh.name)"%(warehouse_details.lft,
				warehouse_details.rgt)

	return conditions
Пример #15
0
	def validate_credit_debit_note(self):
		if self.stock_entry:
			if frappe.db.get_value("Stock Entry", self.stock_entry, "docstatus") != 1:
				frappe.throw(_("Stock Entry {0} is not submitted").format(self.stock_entry))

			if frappe.db.exists({"doctype": "Journal Entry", "stock_entry": self.stock_entry, "docstatus":1}):
				frappe.msgprint(_("Warning: Another {0} # {1} exists against stock entry {2}".format(self.voucher_type, self.name, self.stock_entry)))
Пример #16
0
def validate_item_attribute_value(attributes_list, attribute, attribute_value, item):
	allow_rename_attribute_value = frappe.db.get_single_value('Item Variant Settings', 'allow_rename_attribute_value')
	if allow_rename_attribute_value:
		pass
	elif attribute_value not in attributes_list:
		frappe.throw(_("Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}").format(
			attribute_value, attribute, item), InvalidItemAttributeValueError, title=_('Invalid Attribute'))
Пример #17
0
	def validate_against_jv(self):
		for d in self.get('accounts'):
			if d.reference_type=="Journal Entry":
				account_root_type = frappe.db.get_value("Account", d.account, "root_type")
				if account_root_type == "Asset" and flt(d.debit) > 0:
					frappe.throw(_("For {0}, only credit accounts can be linked against another debit entry")
						.format(d.account))
				elif account_root_type == "Liability" and flt(d.credit) > 0:
					frappe.throw(_("For {0}, only debit accounts can be linked against another credit entry")
						.format(d.account))

				if d.reference_name == self.name:
					frappe.throw(_("You can not enter current voucher in 'Against Journal Entry' column"))

				against_entries = frappe.db.sql("""select * from `tabJournal Entry Account`
					where account = %s and docstatus = 1 and parent = %s
					and (reference_type is null or reference_type in ("", "Sales Order", "Purchase Order"))
					""", (d.account, d.reference_name), as_dict=True)

				if not against_entries:
					frappe.throw(_("Journal Entry {0} does not have account {1} or already matched against other voucher")
						.format(d.reference_name, d.account))
				else:
					dr_or_cr = "debit" if d.credit > 0 else "credit"
					valid = False
					for jvd in against_entries:
						if flt(jvd[dr_or_cr]) > 0:
							valid = True
					if not valid:
						frappe.throw(_("Against Journal Entry {0} does not have any unmatched {1} entry")
							.format(d.reference_name, dr_or_cr))
Пример #18
0
	def validate_orders(self):
		"""Validate totals, closed and docstatus for orders"""
		for reference_name, total in self.reference_totals.iteritems():
			reference_type = self.reference_types[reference_name]
			account = self.reference_accounts[reference_name]

			if reference_type in ("Sales Order", "Purchase Order"):
				order = frappe.get_doc(reference_type, reference_name)

				if order.docstatus != 1:
					frappe.throw(_("{0} {1} is not submitted").format(reference_type, reference_name))

				if flt(order.per_billed) >= 100:
					frappe.throw(_("{0} {1} is fully billed").format(reference_type, reference_name))

				if cstr(order.status) == "Closed":
					frappe.throw(_("{0} {1} is closed").format(reference_type, reference_name))

				account_currency = get_account_currency(account)
				if account_currency == self.company_currency:
					voucher_total = order.base_grand_total
					formatted_voucher_total = fmt_money(voucher_total, order.precision("base_grand_total"),
						currency=account_currency)
				else:
					voucher_total = order.grand_total
					formatted_voucher_total = fmt_money(voucher_total, order.precision("grand_total"),
						currency=account_currency)

				if flt(voucher_total) < (flt(order.advance_paid) + total):
					frappe.throw(_("Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}").format(reference_type, reference_name, formatted_voucher_total))
	def validate_multiple_billing(self, ref_dt, item_ref_dn, based_on, parentfield):
		from erpnext.controllers.status_updater import get_tolerance_for
		item_tolerance = {}
		global_tolerance = None

		for item in self.get("items"):
			if item.get(item_ref_dn):
				ref_amt = flt(frappe.db.get_value(ref_dt + " Item",
					item.get(item_ref_dn), based_on), self.precision(based_on, item))
				if not ref_amt:
					frappe.msgprint(_("Warning: System will not check overbilling since amount for Item {0} in {1} is zero").format(item.item_code, ref_dt))
				else:
					already_billed = frappe.db.sql("""select sum(%s) from `tab%s`
						where %s=%s and docstatus=1 and parent != %s""" %
						(based_on, self.doctype + " Item", item_ref_dn, '%s', '%s'),
						(item.get(item_ref_dn), self.name))[0][0]

					total_billed_amt = flt(flt(already_billed) + flt(item.get(based_on)),
						self.precision(based_on, item))

					tolerance, item_tolerance, global_tolerance = get_tolerance_for(item.item_code,
						item_tolerance, global_tolerance)

					max_allowed_amt = flt(ref_amt * (100 + tolerance) / 100)

					if total_billed_amt - max_allowed_amt > 0.01:
						frappe.throw(_("Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings").format(item.item_code, item.idx, max_allowed_amt))
Пример #20
0
def get_data():
	return [
		{
			"label": _("Documents"),
			"icon": "icon-star",
			"items": [
				
				{
					"type":"doctype",
					"name": "Locate Address On Map",
					"description": _("Locate Address On Map")
				},			
			]
		},
		{
			"label": _("Setup"),
			"icon": "icon-star",
			"items": [
				{
					"type":"doctype",
					"name": "Map Settings",
					"description": _("Map Settings")
				},
				
			]
		},
	]
Пример #21
0
	def validate_value(self, fieldname, condition, val2, doc=None, raise_exception=None):
		"""Check that value of fieldname should be 'condition' val2
			else throw Exception."""
		error_condition_map = {
			"in": _("one of"),
			"not in": _("none of"),
			"^": _("beginning with"),
		}

		if not doc:
			doc = self

		val1 = doc.get_value(fieldname)

		df = doc.meta.get_field(fieldname)
		val2 = doc.cast(val2, df)

		if not frappe.compare(val1, condition, val2):
			label = doc.meta.get_label(fieldname)
			condition_str = error_condition_map.get(condition, condition)
			if doc.parentfield:
				msg = _("Incorrect value in row {0}: {1} must be {2} {3}".format(doc.idx, label, condition_str, val2))
			else:
				msg = _("Incorrect value: {0} must be {1} {2}".format(label, condition_str, val2))

			# raise passed exception or True
			msgprint(msg, raise_exception=raise_exception or True)
Пример #22
0
def add_custom_doctypes(data, doctype_info):
	"""Adds Custom DocTypes to modules setup via `config/desktop.py`."""
	add_section(data, _("Documents"), "icon-star",
		[d for d in doctype_info if (d.custom and d.document_type in ("Document", "Transaction"))])

	add_section(data, _("Setup"), "icon-cog",
		[d for d in doctype_info if (d.custom and d.document_type in ("Setup", "Master", ""))])
Пример #23
0
 def set_transfer_qty(self):
     for item in self.get("items"):
         if not flt(item.qty):
             frappe.throw(_("Row {0}: Qty is mandatory").format(item.idx))
         if not flt(item.conversion_factor):
             frappe.throw(_("Row {0}: UOM Conversion Factor is mandatory").format(item.idx))
         item.transfer_qty = flt(item.qty * item.conversion_factor, self.precision("transfer_qty", item))
Пример #24
0
    def get_gl_entries(self, warehouse_account):
        expenses_included_in_valuation = self.get_company_default("expenses_included_in_valuation")

        gl_entries = super(StockEntry, self).get_gl_entries(warehouse_account)

        for d in self.get("items"):
            additional_cost = flt(d.additional_cost, d.precision("additional_cost"))
            if additional_cost:
                gl_entries.append(
                    self.get_gl_dict(
                        {
                            "account": expenses_included_in_valuation,
                            "against": d.expense_account,
                            "cost_center": d.cost_center,
                            "remarks": self.get("remarks") or _("Accounting Entry for Stock"),
                            "credit": additional_cost,
                        }
                    )
                )

                gl_entries.append(
                    self.get_gl_dict(
                        {
                            "account": d.expense_account,
                            "against": expenses_included_in_valuation,
                            "cost_center": d.cost_center,
                            "remarks": self.get("remarks") or _("Accounting Entry for Stock"),
                            "credit": -1 * additional_cost,  # put it as negative credit instead of debit purposefully
                        }
                    )
                )

        return gl_entries
Пример #25
0
def validate_price_list(args):
	if args.get("price_list"):
		if not frappe.db.get_value("Price List",
			{"name": args.price_list, args.transaction_type: 1, "enabled": 1}):
			throw(_("Price List {0} is disabled").format(args.price_list))
	else:
		throw(_("Price List not selected"))
Пример #26
0
	def _validate_selects(self):
		if frappe.flags.in_import:
			return

		for df in self.meta.get_select_fields():
			if df.fieldname=="naming_series" or not (self.get(df.fieldname) and df.options):
				continue

			options = (df.options or "").split("\n")

			# if only empty options
			if not filter(None, options):
				continue

			# strip and set
			self.set(df.fieldname, cstr(self.get(df.fieldname)).strip())
			value = self.get(df.fieldname)

			if value not in options and not (frappe.flags.in_test and value.startswith("_T-")):
				# show an elaborate message
				prefix = _("Row #{0}:").format(self.idx) if self.get("parentfield") else ""
				label = _(self.meta.get_label(df.fieldname))
				comma_options = '", "'.join(_(each) for each in options)

				frappe.throw(_('{0} {1} cannot be "{2}". It should be one of "{3}"').format(prefix, label,
					value, comma_options))
Пример #27
0
    def validate_purchase_order(self):
        """Throw exception if more raw material is transferred against Purchase Order than in
		the raw materials supplied table"""
        if self.purpose == "Subcontract" and self.purchase_order:
            purchase_order = frappe.get_doc("Purchase Order", self.purchase_order)
            for se_item in self.items:
                total_allowed = sum(
                    [flt(d.required_qty) for d in purchase_order.supplied_items if d.rm_item_code == se_item.item_code]
                )
                if not total_allowed:
                    frappe.throw(
                        _("Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}").format(
                            se_item.item_code, self.purchase_order
                        )
                    )
                total_supplied = frappe.db.sql(
                    """select sum(qty)
					from `tabStock Entry Detail`, `tabStock Entry`
					where `tabStock Entry`.purchase_order = %s
						and `tabStock Entry`.docstatus = 1
						and `tabStock Entry Detail`.item_code = %s
						and `tabStock Entry Detail`.parent = `tabStock Entry`.name""",
                    (self.purchase_order, se_item.item_code),
                )[0][0]

                if total_supplied > total_allowed:
                    frappe.throw(
                        _("Not allowed to tranfer more {0} than {1} against Purchase Order {2}").format(
                            se_item.item_code, total_allowed, self.purchase_order
                        )
                    )
Пример #28
0
	def get_pending_raw_materials(self):
		"""
			issue (item quantity) that is pending to issue or desire to transfer,
			whichever is less
		"""
		item_dict = self.get_bom_raw_materials(1)
		issued_item_qty = self.get_issued_qty()

		max_qty = flt(self.pro_doc.qty)
		only_pending_fetched = []

		for item in item_dict:
			pending_to_issue = (max_qty * item_dict[item]["qty"]) - issued_item_qty.get(item, 0)
			desire_to_transfer = flt(self.fg_completed_qty) * item_dict[item]["qty"]
			if desire_to_transfer <= pending_to_issue:
				item_dict[item]["qty"] = desire_to_transfer
			else:
				item_dict[item]["qty"] = pending_to_issue
				if pending_to_issue:
					only_pending_fetched.append(item)

		# delete items with 0 qty
		for item in item_dict.keys():
			if not item_dict[item]["qty"]:
				del item_dict[item]

		# show some message
		if not len(item_dict):
			frappe.msgprint(_("""All items have already been transferred for this Production Order."""))

		elif only_pending_fetched:
			frappe.msgprint(_("Pending Items {0} updated").format(only_pending_fetched))

		return item_dict
def get_columns():
	return [_("Agent") + ":Link/Agent:200",
			_("First Name") + ":Data:100",
			_("Last Name") + ":Data:120", 
			_("Contact No") + ":Data:160",
			_("Location") + ":Data:250"
		   ]
Пример #30
0
	def check_prev_docstatus(self):
		for d in self.get('items'):
			if d.sales_order and frappe.db.get_value("Sales Order", d.sales_order, "docstatus") != 1:
				frappe.throw(_("Sales Order {0} is not submitted").format(d.sales_order))

			if d.delivery_note and frappe.db.get_value("Delivery Note", d.delivery_note, "docstatus") != 1:
				throw(_("Delivery Note {0} is not submitted").format(d.delivery_note))
Пример #31
0
def get_columns(filters):
    columns = [
        {
            "label": _("Applicant Type"),
            "fieldname": "applicant_type",
            "options": "DocType",
            "width": 100,
        },
        {
            "label": _("Applicant Name"),
            "fieldname": "applicant_name",
            "fieldtype": "Dynamic Link",
            "options": "applicant_type",
            "width": 150,
        },
        {
            "label": _("Loan Security"),
            "fieldname": "loan_security",
            "fieldtype": "Link",
            "options": "Loan Security",
            "width": 160,
        },
        {
            "label": _("Loan Security Code"),
            "fieldname": "loan_security_code",
            "fieldtype": "Data",
            "width": 100,
        },
        {
            "label": _("Loan Security Name"),
            "fieldname": "loan_security_name",
            "fieldtype": "Data",
            "width": 150,
        },
        {
            "label": _("Haircut"),
            "fieldname": "haircut",
            "fieldtype": "Percent",
            "width": 100
        },
        {
            "label": _("Loan Security Type"),
            "fieldname": "loan_security_type",
            "fieldtype": "Link",
            "options": "Loan Security Type",
            "width": 120,
        },
        {
            "label": _("Disabled"),
            "fieldname": "disabled",
            "fieldtype": "Check",
            "width": 80
        },
        {
            "label": _("Total Qty"),
            "fieldname": "total_qty",
            "fieldtype": "Float",
            "width": 100
        },
        {
            "label": _("Latest Price"),
            "fieldname": "latest_price",
            "fieldtype": "Currency",
            "options": "currency",
            "width": 100,
        },
        {
            "label": _("Price Valid Upto"),
            "fieldname": "price_valid_upto",
            "fieldtype": "Datetime",
            "width": 100,
        },
        {
            "label": _("Current Value"),
            "fieldname": "current_value",
            "fieldtype": "Currency",
            "options": "currency",
            "width": 100,
        },
        {
            "label": _("% Of Applicant Portfolio"),
            "fieldname": "portfolio_percent",
            "fieldtype": "Percentage",
            "width": 100,
        },
        {
            "label": _("Currency"),
            "fieldname": "currency",
            "fieldtype": "Currency",
            "options": "Currency",
            "hidden": 1,
            "width": 100,
        },
    ]

    return columns
Пример #32
0
	def validate_rm_item(self, item):
		if (item[0]['name'] in [it.item_code for it in self.items]) and item[0]['name'] == self.item:
			frappe.throw(_("Raw material cannot be same as main Item"))
Пример #33
0
def get_columns(filters):
    """return columns"""

    columns = [
        # {"label": _("Country"), "fieldname": "country", "fieldtype": "Link", "options": "Country", "width": 80},
        # {"label": _("Company"), "fieldname": "company", "fieldtype": "Link", "options": "Company", "width": 200},
        {"label": _("Item"), "fieldname": "item_code", "fieldtype": "Link", "options": "Item", "width": 300},
        {"label": _("Category"), "fieldname": "item_group", "fieldtype": "Link", "options": "Item Group", "width": 150},
        {"label": _("Department"), "fieldname": "department", "fieldtype": "Link", "options": "Department", "width": 200},
        # {"label": _("Category"), "fieldname": "item_group", "fieldtype": "Link", "options": "Item Group", "width": 150},
        {"label": _("Supplier"), "fieldname": "supplier", "fieldtype": "Data","width": 150},
        {"label": _("Part No."), "fieldname": "supplier_part_no", "fieldtype": "Data", "width": 150},
        # {"label": _("Item"), "fieldname": "item_code", "fieldtype": "Link", "options": "Item", "width": 300},
        {"label": _("Warehouse"), "fieldname": "warehouse", "fieldtype": "Link", "options": "Warehouse", "width": 300},
        {"label": _("Balance Qty"), "fieldname": "bal_qty", "fieldtype": "Float", "width": 100, "convertible": "qty"},
        {"label": _("Status"), "fieldname": "status", "fieldtype": "Data", "width": 150}
    ]

    if filters.get('show_stock_ageing_data'):
        columns += [{'label': _('Average Age'), 'fieldname': 'average_age', 'width': 100},
        {'label': _('Earliest Age'), 'fieldname': 'earliest_age', 'width': 100},
        {'label': _('Latest Age'), 'fieldname': 'latest_age', 'width': 100}]

    if filters.get('show_variant_attributes'):
        columns += [{'label': att_name, 'fieldname': att_name, 'width': 100} for att_name in get_variants_attributes()]

    return columns
Пример #34
0
def execute(filters=None):
    if not filters: filters = {}
    
    validate_filters(filters)
    stock_value_in_sc = 0

    from_date = filters.get('from_date')
    to_date = filters.get('to_date')

    include_uom = filters.get("include_uom")
    columns = get_columns(filters)
    items = get_items(filters)
    sle = get_stock_ledger_entries(filters, items)

    if filters.get('show_stock_ageing_data'):
        filters['show_warehouse_wise_stock'] = True
        item_wise_fifo_queue = get_fifo_queue(filters, sle)

    if not sle:
        return columns, []

    if filters.get("currency"):
        columns.extend([
            {"label": _("Currency"), "fieldname": "sc_currency", "fieldtype": "Data", "width": 80},
            {"label": _("Balance Value"), "fieldname": "sc_value", "fieldtype": "Float", "width": 100}
            ])

    if filters.get('warehouse'):
        filters.warehouse = frappe.parse_json(filters.get('warehouse'))

    iwb_map = get_item_warehouse_map(filters, sle)
    item_map = get_item_details(items, sle, filters)
    item_reorder_detail_map = get_item_reorder_details(item_map.keys())

    data = []
    test = []
    conversion_factors = {}

    _func = lambda x: x[1]
    item_head = []
    for (company, item, warehouse) in sorted(iwb_map):
        if not item in item_head:
            item_info = get_parent_details(item, filters)
            data.append({
                'item_code': item,
                'bal_qty': item_info.bal_qty,
                'indent': 0
                })
            item_head.append(item)
        if item_map.get(item):
            qty_dict = iwb_map[(company, item, warehouse)]
            item_reorder_level = 0
            item_reorder_qty = 0
            if item + warehouse in item_reorder_detail_map:
                item_reorder_level = item_reorder_detail_map[item + warehouse]["warehouse_reorder_level"]
                item_reorder_qty = item_reorder_detail_map[item + warehouse]["warehouse_reorder_qty"]

            supplier = supplier_part_no = ''
            supplier_info = frappe.get_value('Item Supplier',{'parent':item},['supplier','supplier_part_no'])
            if supplier_info:
                supplier = supplier_info[0]
                supplier_part_no = supplier_info[1]
            report_data = {
                'item_code': item,
                'warehouse': warehouse,
                'company': company,
                'supplier': supplier,
                'indent': 1,
                'supplier_part_no': supplier_part_no,
                'bal_val_cur':frappe.db.get_value('Company',company, "default_currency"),
                'country': frappe.get_value('Warehouse',warehouse,'country'),
                'reorder_level': item_reorder_level,
                'reorder_qty': item_reorder_qty,
                'indent': 1
            }
            report_data.update(item_map[item])
            report_data.update(qty_dict)

            if include_uom:
                conversion_factors.setdefault(item, item_map[item].conversion_factor)

            if filters.get('show_stock_ageing_data'):
                fifo_queue = item_wise_fifo_queue[(item, warehouse)].get('fifo_queue')

                stock_ageing_data = {
                    'average_age': 0,
                    'earliest_age': 0,
                    'latest_age': 0
                }
                if fifo_queue:
                    fifo_queue = sorted(filter(_func, fifo_queue), key=_func)
                    if not fifo_queue: continue

                    stock_ageing_data['average_age'] = get_average_age(fifo_queue, to_date)
                    stock_ageing_data['earliest_age'] = date_diff(to_date, fifo_queue[0][1])
                    stock_ageing_data['latest_age'] = date_diff(to_date, fifo_queue[-1][1])

                report_data.update(stock_ageing_data)	
            data.append(report_data)

    add_additional_uom_columns(columns, data, include_uom, conversion_factors)
    sc_val_cur = ''
    sc_val = 0
    
    for d in data:
        status = 'Ideal Quantity'
        if d['indent'] != 0:
            if int(d['bal_qty']) <= int(d['reorder_level']):
                status = 'Low Quantity'

            frozen = frappe.get_value('Item',d['item_code'],'disabled')
            if frozen:
                status = 'Frozen Item'	


            if filters.get("currency"):
                default_currency = d['bal_val_cur']
                selected_currency = filters.currency
                exchange_rate = frappe.get_value('Currency Exchange',{'from_currency':default_currency,'to_currency':selected_currency},['exchange_rate'])
                if filters.get('currency') == default_currency:
                    exchange_rate = 1
                sc_val_cur = frappe.db.get_value('Currency',selected_currency,['name'])
                sc_val = d['bal_val'] * flt(exchange_rate)	

            # if no stock ledger entry found return
            converted_value = {
                'sc_currency': sc_val_cur,
                'sc_value' : sc_val,
                'status': status
            }
            d.update(converted_value)
    data = sorted(data, key=lambda x: x['item_code'])
    from collections import defaultdict
    tmp = defaultdict(list)
    for item in data:
        if item['indent'] != 0:
            tmp[item['item_code']].append([item['warehouse'],item['bal_qty']])
    parsed_data = [{'item_code':k, 'warehouse':v[0][0], 'indent':1} for k,v in tmp.items()]
    # frappe.errprint(parsed_data)
    return columns,data
Пример #35
0
		def get_state(state):
			for s in self.states:
				if s.state==state:
					return s

			frappe.throw(frappe._("{0} not a valid State").format(state))
Пример #36
0
def get_data():
    return [
        {
            "label":
            _("Documents"),
            "icon":
            "icon-star",
            "items": [
                {
                    "type": "doctype",
                    "name": "Supplier",
                    "description": _("Supplier database."),
                },
                {
                    "type": "doctype",
                    "name": "Material Request",
                    "description": _("Request for purchase."),
                },
                {
                    "type": "doctype",
                    "name": "Request For Quote",
                    "description": _("Request For Quote."),
                },
                {
                    "type": "doctype",
                    "name": "Supplier Quotation",
                    "description": _("Quotations received from Suppliers."),
                },
                {
                    "type": "doctype",
                    "name": "Purchase Order",
                    "description": _("Purchase Orders given to Suppliers."),
                },
                {
                    "type": "doctype",
                    "name": "Contact",
                    "description": _("All Contacts."),
                },
                {
                    "type": "doctype",
                    "name": "Address",
                    "description": _("All Addresses."),
                },
                {
                    "type": "doctype",
                    "name": "Item",
                    "description": _("All Products or Services."),
                },
            ]
        },
        {
            "label":
            _("Setup"),
            "icon":
            "icon-cog",
            "items": [
                {
                    "type": "doctype",
                    "name": "Buying Settings",
                    "description":
                    _("Default settings for buying transactions.")
                },
                {
                    "type": "doctype",
                    "name": "Supplier Type",
                    "description": _("Supplier Type master.")
                },
                {
                    "type": "page",
                    "name": "Sales Browser",
                    "icon": "icon-sitemap",
                    "label": _("Item Group Tree"),
                    "link": "Sales Browser/Item Group",
                    "description": _("Tree of Item Groups."),
                    "doctype": "Item Group",
                },
                {
                    "type": "doctype",
                    "name": "Terms and Conditions",
                    "label": _("Terms and Conditions Template"),
                    "description": _("Template of terms or contract.")
                },
                {
                    "type": "doctype",
                    "name": "Purchase Taxes and Charges Template",
                    "description": _("Tax template for buying transactions.")
                },
                {
                    "type": "doctype",
                    "name": "Price List",
                    "description": _("Price List master.")
                },
                {
                    "type": "doctype",
                    "name": "Item Price",
                    "description": _("Multiple Item prices."),
                    "route": "Report/Item Price"
                },
                {
                    "type": "doctype",
                    "name": "Pricing Rule",
                    "description":
                    _("Rules for applying pricing and discount.")
                },
            ]
        },
        {
            "label":
            _("Main Reports"),
            "icon":
            "icon-table",
            "items": [
                {
                    "type": "page",
                    "name": "purchase-analytics",
                    "label": _("Purchase Analytics"),
                    "icon": "icon-bar-chart",
                },
            ]
        },
        {
            "label":
            _("Standard Reports"),
            "icon":
            "icon-list",
            "items": [{
                "type": "report",
                "is_query_report": True,
                "name": "Items To Be Requested",
                "doctype": "Item"
            }, {
                "type": "report",
                "is_query_report": True,
                "name": "Requested Items To Be Ordered",
                "doctype": "Material Request"
            }, {
                "type": "report",
                "is_query_report": True,
                "name":
                "Material Requests for which Supplier Quotations are not created",
                "doctype": "Material Request"
            }, {
                "type": "report",
                "is_query_report": True,
                "name": "Item-wise Purchase History",
                "doctype": "Item"
            }, {
                "type": "report",
                "is_query_report": True,
                "name": "Purchase Order Trends",
                "doctype": "Purchase Order"
            }, {
                "type": "report",
                "is_query_report": True,
                "name": "Supplier Addresses and Contacts",
                "doctype": "Supplier"
            }, {
                "type": "report",
                "is_query_report": True,
                "name": "Supplier-Wise Sales Analytics",
                "doctype": "Stock Ledger Entry"
            }]
        },
        {
            "label":
            _("Help"),
            "items": [
                {
                    "type": "help",
                    "label": _("Customer and Supplier"),
                    "youtube_id": "anoGi_RpQ20"
                },
                {
                    "type": "help",
                    "label": _("Material Request to Purchase Order"),
                    "youtube_id": "4TN9kPyfIqM"
                },
                {
                    "type": "help",
                    "label": _("Purchase Order to Payment"),
                    "youtube_id": "EK65tLdVUDk"
                },
                {
                    "type": "help",
                    "label": _("Managing Subcontracting"),
                    "youtube_id": "ThiMCC2DtKo"
                },
            ]
        },
    ]
def get_columns():
    return [
        _("Item") + ":Link/Item:120",
        _("Item Name") + ":Data:120",
        _("Item Group") + ":Link/Item Group:100",
        _("Brand") + ":Link/Brand:100",
        _("Description") + "::160",
        _("Safety Stock") + ":Float:160",
        _("Lead Time Days") + ":Float:120",
        _("Consumed") + ":Float:120",
        _("Delivered") + ":Float:120",
        _("Total Outgoing") + ":Float:120",
        _("Avg Daily Outgoing") + ":Float:160",
        _("Reorder Level") + ":Float:120"
    ]
Пример #38
0
def get_columns():
    """return columns"""
    columns = [
        _("SREQ No") + ":Link/Stock Requisition:100",
        _("Project") + ":Link/Project:100",
        _("SREQ Item") + ":Link/Item:100",
        _("SREQ Quantity") + "::100",
        _("SREQ UOM") + "::140",
        _("Stock UOM") + "::100",
        _("SREQ Quantity in Stock UOM") + "::150",
        _("Quantity Available in Source Warehouse (Stock UOM)") + "::150",
        _("Excess to be Ordered") + "::90",
        _("PO UOM") + "::100",
        _("Conversion Factor") + "::",
        _("Qty in PO UOM") + "::100",
        _("Default Supplier") + "::140",
        _("Last Purchase Price (Stock UOM)") + "::100",
        _("Number of Purchase Transactions") + "::150",
        _("Highest Price of Last 10 Purchase Transactions (Stock UOM)") +
        "::90",
        _("Lowest Price of Last 10 Purchase Transactions (Stock UOM)") +
        "::100",
        _("Average of Last 10 Purchase Transactions") + "::150"
    ]
    return columns
Пример #39
0
def get_list_context(context):
	context.title = _("Bill of Materials")
Пример #40
0
	def get_context(self, context):
		context.parents = [{'name': 'boms', 'title': _('All BOMs') }]
Пример #41
0
	def validate_bom_currecny(self, item):
		if item.get('bom_no') and frappe.db.get_value('BOM', item.get('bom_no'), 'currency') != self.currency:
			frappe.throw(_("Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}").format(item.idx, item.bom_no, self.currency))
Пример #42
0
	def validate_currency(self):
		if self.rm_cost_as_per == 'Price List' and \
			frappe.db.get_value('Price List', self.buying_price_list, 'currency') != self.currency:
			frappe.throw(_("Currency of the price list {0} is not similar with the selected currency {1}").format(self.buying_price_list, self.currency))
Пример #43
0
def get_data():
    return [
        {
            "label":
            _("Employee"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Employee",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Employment Type",
                },
                {
                    "type": "doctype",
                    "name": "Branch",
                },
                {
                    "type": "doctype",
                    "name": "Department",
                },
                {
                    "type": "doctype",
                    "name": "Designation",
                },
                {
                    "type": "doctype",
                    "name": "Employee Grade",
                },
                {
                    "type": "doctype",
                    "name": "Employee Group",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Health Insurance"
                },
            ]
        },
        {
            "label":
            _("Attendance"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Employee Attendance Tool",
                    "hide_count": True,
                    "onboard": 1,
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Attendance",
                    "onboard": 1,
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Attendance Request",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Upload Attendance",
                    "hide_count": True,
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Checkin",
                    "hide_count": True,
                    "dependencies": ["Employee"]
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Monthly Attendance Sheet",
                    "doctype": "Attendance"
                },
            ]
        },
        {
            "label":
            _("Leaves"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Leave Application",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Allocation",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Policy",
                    "dependencies": ["Leave Type"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Period",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Type",
                },
                {
                    "type": "doctype",
                    "name": "Holiday List",
                },
                {
                    "type": "doctype",
                    "name": "Compensatory Leave Request",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Encashment",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Leave Block List",
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Employee Leave Balance",
                    "doctype": "Leave Application"
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Leave Ledger Entry",
                    "doctype": "Leave Ledger Entry"
                },
            ]
        },
        {
            "label":
            _("Payroll"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Salary Structure",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Salary Structure Assignment",
                    "onboard": 1,
                    "dependencies": ["Salary Structure", "Employee"],
                },
                {
                    "type": "doctype",
                    "name": "Payroll Entry",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Salary Slip",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Payroll Period",
                },
                {
                    "type": "doctype",
                    "name": "Salary Component",
                },
                {
                    "type": "doctype",
                    "name": "Additional Salary",
                },
                {
                    "type": "doctype",
                    "name": "Retention Bonus",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Incentive",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Salary Register",
                    "doctype": "Salary Slip"
                },
            ]
        },
        {
            "label":
            _("Employee Tax and Benefits"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Employee Tax Exemption Declaration",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Tax Exemption Proof Submission",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Benefit Application",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Benefit Claim",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Tax Exemption Category",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Tax Exemption Sub Category",
                    "dependencies": ["Employee"]
                },
            ]
        },
        {
            "label":
            _("Employee Lifecycle"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Employee Onboarding",
                    "dependencies": ["Job Applicant"],
                },
                {
                    "type": "doctype",
                    "name": "Employee Skill Map",
                    "dependencies": ["Employee"],
                },
                {
                    "type": "doctype",
                    "name": "Employee Promotion",
                    "dependencies": ["Employee"],
                },
                {
                    "type": "doctype",
                    "name": "Employee Transfer",
                    "dependencies": ["Employee"],
                },
                {
                    "type": "doctype",
                    "name": "Employee Separation",
                    "dependencies": ["Employee"],
                },
                {
                    "type": "doctype",
                    "name": "Employee Onboarding Template",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Separation Template",
                    "dependencies": ["Employee"]
                },
            ]
        },
        {
            "label":
            _("Recruitment"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Job Opening",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Job Applicant",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Job Offer",
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Staffing Plan",
                },
            ]
        },
        {
            "label":
            _("Training"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Training Program"
                },
                {
                    "type": "doctype",
                    "name": "Training Event"
                },
                {
                    "type": "doctype",
                    "name": "Training Result"
                },
                {
                    "type": "doctype",
                    "name": "Training Feedback"
                },
            ]
        },
        {
            "label":
            _("Performance"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Appraisal",
                },
                {
                    "type": "doctype",
                    "name": "Appraisal Template",
                },
                {
                    "type": "doctype",
                    "name": "Energy Point Rule",
                },
                {
                    "type": "doctype",
                    "name": "Energy Point Log",
                },
                {
                    "type": "link",
                    "doctype": "Energy Point Log",
                    "label": _("Energy Point Leaderboard"),
                    "route": "#social/users"
                },
            ]
        },
        {
            "label":
            _("Expense Claims"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Expense Claim",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Employee Advance",
                    "dependencies": ["Employee"]
                },
            ]
        },
        {
            "label":
            _("Loans"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Loan Application",
                    "dependencies": ["Employee"]
                },
                {
                    "type": "doctype",
                    "name": "Loan"
                },
                {
                    "type": "doctype",
                    "name": "Loan Type",
                },
            ]
        },
        {
            "label":
            _("Shift Management"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Shift Type",
                },
                {
                    "type": "doctype",
                    "name": "Shift Request",
                },
                {
                    "type": "doctype",
                    "name": "Shift Assignment",
                },
            ]
        },
        {
            "label":
            _("Fleet Management"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Vehicle"
                },
                {
                    "type": "doctype",
                    "name": "Vehicle Log"
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Vehicle Expenses",
                    "doctype": "Vehicle"
                },
            ]
        },
        {
            "label":
            _("Settings"),
            "icon":
            "fa fa-cog",
            "items": [
                {
                    "type": "doctype",
                    "name": "HR Settings",
                },
                {
                    "type": "doctype",
                    "name": "Daily Work Summary Group"
                },
                {
                    "type": "page",
                    "name": "team-updates",
                    "label": _("Team Updates")
                },
            ]
        },
        {
            "label":
            _("Reports"),
            "icon":
            "fa fa-list",
            "items": [
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Employee Birthday",
                    "doctype": "Employee"
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Employees working on a holiday",
                    "doctype": "Employee"
                },
                {
                    "type": "report",
                    "is_query_report": True,
                    "name": "Department Analytics",
                    "doctype": "Employee"
                },
            ]
        },
    ]
Пример #44
0
def get_single_value(doctype, field):
    if not frappe.has_permission(doctype):
        frappe.throw(_("No permission for {doctype}".format(doctype=doctype)),
                     frappe.PermissionError)
    value = frappe.db.get_single_value(doctype, field)
    return value
Пример #45
0
 def validate_cancellation(self):
     if self.status not in ("Submitted", "Partially Depreciated",
                            "Fully Depreciated"):
         frappe.throw(
             _("Asset cannot be cancelled, as it is already {0}").format(
                 self.status))
Пример #46
0
 def validate_in_use_date(self):
     if not self.available_for_use_date:
         frappe.throw(_("Available for use date is required"))
Пример #47
0
def make_payment_request(**args):
	"""Make payment request"""

	args = frappe._dict(args)

	ref_doc = frappe.get_doc(args.dt, args.dn)
	grand_total = get_amount(ref_doc)
	if args.loyalty_points and args.dt == "Sales Order":
		from erpnext.accounts.doctype.loyalty_program.loyalty_program import validate_loyalty_points
		loyalty_amount = validate_loyalty_points(ref_doc, int(args.loyalty_points))
		frappe.db.set_value("Sales Order", args.dn, "loyalty_points", int(args.loyalty_points), update_modified=False)
		frappe.db.set_value("Sales Order", args.dn, "loyalty_amount", loyalty_amount, update_modified=False)
		grand_total = grand_total - loyalty_amount

	gateway_account = get_gateway_details(args) or frappe._dict()

	bank_account = (get_party_bank_account(args.get('party_type'), args.get('party'))
		if args.get('party_type') else '')

	existing_payment_request = None
	if args.order_type == "Shopping Cart":
		existing_payment_request = frappe.db.get_value("Payment Request",
			{"reference_doctype": args.dt, "reference_name": args.dn, "docstatus": ("!=", 2)})

	if existing_payment_request:
		frappe.db.set_value("Payment Request", existing_payment_request, "grand_total", grand_total, update_modified=False)
		pr = frappe.get_doc("Payment Request", existing_payment_request)
	else:
		if args.order_type != "Shopping Cart":
			existing_payment_request_amount = \
				get_existing_payment_request_amount(args.dt, args.dn)

			if existing_payment_request_amount:
				grand_total -= existing_payment_request_amount

		pr = frappe.new_doc("Payment Request")
		pr.update({
			"payment_gateway_account": gateway_account.get("name"),
			"payment_gateway": gateway_account.get("payment_gateway"),
			"payment_account": gateway_account.get("payment_account"),
			"payment_request_type": args.get("payment_request_type"),
			"currency": ref_doc.currency,
			"grand_total": grand_total,
			"email_to": args.recipient_id or "",
			"subject": _("Payment Request for {0}").format(args.dn),
			"message": gateway_account.get("message") or get_dummy_message(ref_doc),
			"reference_doctype": args.dt,
			"reference_name": args.dn,
			"party_type": args.get("party_type"),
			"party": args.get("party"),
			"bank_account": bank_account
		})

		if args.order_type == "Shopping Cart" or args.mute_email:
			pr.flags.mute_email = True

		if args.submit_doc:
			pr.insert(ignore_permissions=True)
			pr.submit()

	if args.order_type == "Shopping Cart":
		frappe.db.commit()
		frappe.local.response["type"] = "redirect"
		frappe.local.response["location"] = pr.get_payment_url()

	if args.return_doc:
		return pr

	return pr.as_dict()
Пример #48
0
	def validate_currency(self):
		ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
		if self.payment_account and ref_doc.currency != frappe.db.get_value("Account", self.payment_account, "account_currency"):
			frappe.throw(_("Transaction currency must be same as Payment Gateway currency"))
Пример #49
0
def validate_filters(filters):
    if not (filters.get("item_code") or filters.get("warehouse")):
        sle_count = flt(frappe.db.sql("""select count(name) from `tabStock Ledger Entry`""")[0][0])
        if sle_count > 500000:
            frappe.throw(_("Please set filter based on Item or Warehouse due to a large amount of entries."))
Пример #50
0
	def validate_reference_document(self):
		if not self.reference_doctype or not self.reference_name:
			frappe.throw(_("To create a Payment Request reference document is required"))
Пример #51
0
def validate_employee_role(doc, method):
	# called via User hook
	if "Employee" in [d.role for d in doc.get("roles")]:
		if not frappe.db.get_value("Employee", {"user_id": doc.name}):
			frappe.msgprint(_("Please set User ID field in an Employee record to set Employee Role"))
			doc.get("roles").remove(doc.get("roles", {"role": "Employee"})[0])
Пример #52
0
 def set_title(self):
     self.title = _("{0} for {1}").format(self.employee_name,
                                          self.activity_type)
Пример #53
0
def validate_returned_items(doc):
	from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos

	valid_items = frappe._dict()

	select_fields = "item_code, qty, stock_qty, rate, parenttype, conversion_factor"
	if doc.doctype != 'Purchase Invoice':
		select_fields += ",serial_no, batch_no"

	if doc.doctype in ['Purchase Invoice', 'Purchase Receipt']:
		select_fields += ",rejected_qty, received_qty"

	for d in frappe.db.sql("""select {0} from `tab{1} Item` where parent = %s"""
		.format(select_fields, doc.doctype), doc.return_against, as_dict=1):
			valid_items = get_ref_item_dict(valid_items, d)

	if doc.doctype in ("Delivery Note", "Sales Invoice"):
		for d in frappe.db.sql("""select item_code, qty, serial_no, batch_no from `tabPacked Item`
			where parent = %s""".format(doc.doctype), doc.return_against, as_dict=1):
				valid_items = get_ref_item_dict(valid_items, d)

	already_returned_items = get_already_returned_items(doc)

	# ( not mandatory when it is Purchase Invoice or a Sales Invoice without Update Stock )
	warehouse_mandatory = not ((doc.doctype=="Purchase Invoice" or doc.doctype=="Sales Invoice") and not doc.update_stock)

	items_returned = False
	for d in doc.get("items"):
		if flt(d.qty) < 0 or d.get('received_qty') < 0:
			if d.item_code not in valid_items:
				frappe.throw(_("Row # {0}: Returned Item {1} does not exists in {2} {3}")
					.format(d.idx, d.item_code, doc.doctype, doc.return_against))
			else:
				ref = valid_items.get(d.item_code, frappe._dict())
				validate_quantity(doc, d, ref, valid_items, already_returned_items)

				if ref.rate and doc.doctype in ("Delivery Note", "Sales Invoice") and flt(d.rate) > ref.rate:
					frappe.throw(_("Row # {0}: Rate cannot be greater than the rate used in {1} {2}")
						.format(d.idx, doc.doctype, doc.return_against))

				elif ref.batch_no and d.batch_no not in ref.batch_no:
					frappe.throw(_("Row # {0}: Batch No must be same as {1} {2}")
						.format(d.idx, doc.doctype, doc.return_against))

				elif ref.serial_no:
					if not d.serial_no:
						frappe.throw(_("Row # {0}: Serial No is mandatory").format(d.idx))
					else:
						serial_nos = get_serial_nos(d.serial_no)
						for s in serial_nos:
							if s not in ref.serial_no:
								frappe.throw(_("Row # {0}: Serial No {1} does not match with {2} {3}")
									.format(d.idx, s, doc.doctype, doc.return_against))

				if warehouse_mandatory and frappe.db.get_value("Item", d.item_code, "is_stock_item") \
					and not d.get("warehouse"):
						frappe.throw(_("Warehouse is mandatory"))

			items_returned = True

	if not items_returned:
		frappe.throw(_("Atleast one item should be entered with negative quantity in return document"))
Пример #54
0
def get_data():
    return [
        {
            "label":
            _("Web Site"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Web Page",
                    "description": _("Content web page."),
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Web Form",
                    "description": _("User editable form on Website."),
                    "onboard": 1,
                },
                {
                    "type": "doctype",
                    "name": "Website Sidebar",
                },
                {
                    "type": "doctype",
                    "name": "Website Slideshow",
                    "description":
                    _("Embed image slideshows in website pages."),
                },
                {
                    "type": "doctype",
                    "name": "Website Route Meta",
                    "description": _("Add meta tags to your web pages"),
                },
            ]
        },
        {
            "label":
            _("Blog"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Blog Post",
                    "description": _("Single Post (article)."),
                    "onboard": 1,
                },
                {
                    "type":
                    "doctype",
                    "name":
                    "Blog Settings",
                    "description":
                    _("Write titles and introductions to your blog."),
                },
                {
                    "type": "doctype",
                    "name": "Blog Category",
                    "description": _("Categorize blog posts."),
                },
            ]
        },
        {
            "label":
            _("Setup"),
            "items": [
                {
                    "type":
                    "doctype",
                    "name":
                    "Website Settings",
                    "description":
                    _("Setup of top navigation bar, footer and logo."),
                    "onboard":
                    1,
                },
                {
                    "type": "doctype",
                    "name": "Website Theme",
                    "description": _("List of themes for Website."),
                    "onboard": 1,
                },
                {
                    "type":
                    "doctype",
                    "name":
                    "Website Script",
                    "description":
                    _("Javascript to append to the head section of the page."),
                    "onboard":
                    1,
                },
                {
                    "type": "doctype",
                    "name": "About Us Settings",
                    "description": _("Settings for About Us Page."),
                },
                {
                    "type": "doctype",
                    "name": "Contact Us Settings",
                    "description": _("Settings for Contact Us Page."),
                },
            ]
        },
        {
            "label":
            _("Portal"),
            "items": [{
                "type": "doctype",
                "name": "Portal Settings",
                "label": _("Portal Settings"),
                "onboard": 1,
            }]
        },
        {
            "label":
            _("Knowledge Base"),
            "items": [
                {
                    "type": "doctype",
                    "name": "Help Category",
                },
                {
                    "type": "doctype",
                    "name": "Help Article",
                },
            ]
        },
    ]
Пример #55
0
def check_duplicate_fiscal_year(doc):
	year_start_end_dates = frappe.db.sql("""select name, year_start_date, year_end_date from `tabFiscal Year` where name!=%s""", (doc.name))
	for fiscal_year, ysd, yed in year_start_end_dates:
		if (getdate(doc.year_start_date) == ysd and getdate(doc.year_end_date) == yed) and (not frappe.flags.in_test):
					frappe.throw(_("Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}").format(fiscal_year))
Пример #56
0
	def validate_valid_till(self):
		if self.valid_till and getdate(self.valid_till) < getdate(self.transaction_date):
			frappe.throw(_("Valid till date cannot be before transaction date"))
Пример #57
0
	def validate_preferred_email(self):
		if self.prefered_contact_email and not self.get(scrub(self.prefered_contact_email)):
			frappe.msgprint(_("Please enter " + self.prefered_contact_email))
Пример #58
0
        return {
            "redirect_to":
            frappe.redirect_to_message(
                _('Server Error'),
                _("Seems issue with server's razorpay config. Don't worry, in case of failure amount will get refunded to your account."
                  )),
            "status":
            401
        }

    except InvalidRequest, e:
        make_log_entry(e.message, options)
        return {
            "redirect_to":
            frappe.redirect_to_message(
                _('Server Error'),
                _("Seems issue with server's razorpay config. Don't worry, in case of failure amount will get refunded to your account."
                  )),
            "status":
            400
        }

    except GatewayError, e:
        make_log_entry(e.message, options)
        return {
            "redirect_to":
            frappe.redirect_to_message(
                _('Server Error'),
                _("Seems issue with server's razorpay config. Don't worry, in case of failure amount will get refunded to your account."
                  )),
            "status":
Пример #59
0
	def validate_reports_to(self):
		if self.reports_to == self.name:
			throw(_("Employee cannot report to himself."))
Пример #60
0
	def on_trash(self):
		global_defaults = frappe.get_doc("Global Defaults")
		if global_defaults.current_fiscal_year == self.name:
			frappe.throw(_("You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings").format(self.name))
		frappe.cache().delete_value("fiscal_years")