Example #1
0
def get_formatted_value(value, add_symbol=True):
	"""return formatted value"""
	if not add_symbol:
		return '{:.{pre}f}'.format(value, pre=(get_currency_precision() or 2))
	currency_precision = get_currency_precision() or 2
	company = frappe.db.get_default("company")
	currency = frappe.get_doc("Company", company).default_currency or frappe.boot.sysdefaults.currency
	return fmt_money(value, currency_precision, currency)
Example #2
0
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2
		dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		voucher_details = self.get_voucher_details(args.get("party_type"))

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		company_currency = frappe.db.get_value("Company", self.filters.get("company"), "default_currency")

		data = []
		for gle in self.get_entries_till(self.filters.report_date, args.get("party_type")):
			if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
				outstanding_amount = self.get_outstanding_amount(gle, self.filters.report_date, dr_or_cr)
				if abs(outstanding_amount) > 0.1/10**currency_precision:

					row = [gle.posting_date, gle.party]

					# customer / supplier name
					if party_naming_by == "Naming Series":
						row += [self.get_party_name(gle.party_type, gle.party)]

					# get due date
					due_date = voucher_details.get(gle.voucher_no, {}).get("due_date", "")

					row += [gle.voucher_type, gle.voucher_no, due_date]

					# get supplier bill details
					if args.get("party_type") == "Supplier":
						row += [
							voucher_details.get(gle.voucher_no, {}).get("bill_no", ""),
							voucher_details.get(gle.voucher_no, {}).get("bill_date", "")
						]

					# invoiced and paid amounts
					invoiced_amount = gle.get(dr_or_cr) if (gle.get(dr_or_cr) > 0) else 0
					paid_amt = invoiced_amount - outstanding_amount
					row += [invoiced_amount, paid_amt, outstanding_amount]

					# ageing data
					entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
					row += get_ageing_data(cint(self.filters.range1), cint(self.filters.range2),
						cint(self.filters.range3), self.age_as_on, entry_date, outstanding_amount)

					# customer territory / supplier type
					if args.get("party_type") == "Customer":
						row += [self.get_territory(gle.party)]
					if args.get("party_type") == "Supplier":
						row += [self.get_supplier_type(gle.party)]

					if self.filters.get(scrub(args.get("party_type"))):
						row.append(gle.account_currency)
					else:
						row.append(company_currency)

					row.append(gle.remarks)
					data.append(row)

		return data
	def get_data(self, customer_naming_by):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2

		data = []
		future_vouchers = self.get_entries_after(self.filters.report_date)
		for gle in self.get_entries_till(self.filters.report_date):
			if self.is_receivable(gle, future_vouchers):
				outstanding_amount = self.get_outstanding_amount(gle, self.filters.report_date)
				if abs(outstanding_amount) > 0.1/10**currency_precision:
					due_date = self.get_due_date(gle)
					invoiced_amount = gle.debit if (gle.debit > 0) else 0
					payment_received = invoiced_amount - outstanding_amount
					row = [gle.posting_date, gle.account,
						gle.voucher_type, gle.voucher_no, due_date,
						invoiced_amount, payment_received,
						outstanding_amount]
					entry_date = due_date if self.filters.ageing_based_on == "Due Date" \
						else gle.posting_date
					row += get_ageing_data(self.age_as_on, entry_date, outstanding_amount) + \
						[self.get_customer(gle.account)]

					if customer_naming_by == "Naming Series":
						row += [self.get_customer_name(gle.account)]

					row += [self.get_territory(gle.account), gle.remarks]
					data.append(row)
		return data
Example #4
0
	def get_data(self, customer_naming_by):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2

		data = []
		future_vouchers = self.get_entries_after(self.filters.report_date)
		for gle in self.get_entries_till(self.filters.report_date):
			if self.is_receivable(gle, future_vouchers):
				outstanding_amount = self.get_outstanding_amount(gle, self.filters.report_date)
				if abs(outstanding_amount) > 0.1/10**currency_precision:
					due_date = self.get_due_date(gle)
					invoiced_amount = gle.debit if (gle.debit > 0) else 0
					payment_received = invoiced_amount - outstanding_amount
					row = [gle.posting_date, gle.account,
						gle.voucher_type, gle.voucher_no, due_date,
						invoiced_amount, payment_received,
						outstanding_amount]
					entry_date = due_date if self.filters.ageing_based_on == "Due Date" \
						else gle.posting_date
					row += get_ageing_data(self.age_as_on, entry_date, outstanding_amount) + \
						[self.get_customer(gle.account)]

					if customer_naming_by == "Naming Series":
						row += [self.get_customer_name(gle.account)]

					row += [self.get_territory(gle.account), gle.remarks]
					data.append(row)
		
		for i in range(0, len(data)):
			data[i].insert(4, """<a href="%s"><i class="icon icon-share" style="cursor: pointer;"></i></a>""" \
				% ("/".join(["#Form", data[i][2], data[i][3]]),))
		
		return data
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2
		dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		voucher_details = self.get_voucher_details(args.get("party_type"))

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		data = []
		for gle in self.get_entries_till(self.filters.report_date, args.get("party_type")):
			if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
				outstanding_amount = self.get_outstanding_amount(gle, self.filters.report_date, dr_or_cr)
				if abs(outstanding_amount) > 0.1/10**currency_precision:

					row = [gle.posting_date, gle.party]
					# customer / supplier name
					if party_naming_by == "Naming Series":
						row += [self.get_party_name(gle.party_type, gle.party)]

					row += [outstanding_amount]

					# ageing data
					entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
					row += get_ageing_data(cint(self.filters.range1), cint(self.filters.range2),
						cint(self.filters.range3), self.age_as_on, entry_date, outstanding_amount)

					data.append(row)

		return data
Example #6
0
def execute(filters=None):
	if not filters: filters = {}
	
	columns = get_columns(filters)
	item_map = get_item_details()
	pl = get_price_list()
	last_purchase_rate = get_last_purchase_rate()
	bom_rate = get_item_bom_rate()
	val_rate_map = get_valuation_rate()

	from erpnext.accounts.utils import get_currency_precision
	precision = get_currency_precision() or 2
	data = []
	for item in sorted(item_map):
		data.append([item, item_map[item]["item_name"], 
			item_map[item]["description"], item_map[item]["stock_uom"], 
			flt(last_purchase_rate.get(item, 0), precision), 
			flt(val_rate_map.get(item, 0), precision), 
			pl.get(item, {}).get("Selling"), 
			pl.get(item, {}).get("Buying"), 
			flt(bom_rate.get(item, 0), precision), 
			flt(item_map[item]["standard_rate"], precision)
		])
	
	return columns, data
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2
		dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		voucher_details = self.get_voucher_details(args.get("party_type"))

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		if not self.filters.get("company"):
			self.filters["company"] = frappe.db.get_single_value('Global Defaults', 'default_company')

		company_currency = frappe.db.get_value("Company", self.filters.get("company"), "default_currency")

		return_entries = self.get_return_entries(args.get("party_type"))

		data = []
		for gle in self.get_entries_till(self.filters.report_date, args.get("party_type")):
			if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
				outstanding_amount, credit_note_amount = self.get_outstanding_amount(gle,
					self.filters.report_date, dr_or_cr, return_entries, currency_precision)
				if abs(outstanding_amount) > 0.1/10**currency_precision:
					row = [gle.posting_date, gle.party]

					# customer / supplier name
					if party_naming_by == "Naming Series":
						row += [self.get_party_name(gle.party_type, gle.party)]

					# get due date
					due_date = voucher_details.get(gle.voucher_no, {}).get("due_date", "")

					# get tax no
					# tax_no = voucher_details.get(gle.voucher_no, {}).get("tax_no", "")

                    # get switch_charge_method
					# switch_charge_method = voucher_details.get(gle.voucher_no, {}).get("switch_charge_method", "")


					# row += [gle.voucher_type, gle.voucher_no, tax_no, switch_charge_method, due_date]
					row += [gle.voucher_type, gle.voucher_no, due_date]

					# get supplier bill details
					if args.get("party_type") == "Supplier":
						row += [
                            #voucher_details.get(gle.voucher_no, {}).get("tax_no", ""),
							voucher_details.get(gle.voucher_no, {}).get("bill_no", ""),
							voucher_details.get(gle.voucher_no, {}).get("bill_date", "")
						]

					# invoiced and paid amounts
					invoiced_amount = gle.get(dr_or_cr) if (gle.get(dr_or_cr) > 0) else 0
					paid_amt = invoiced_amount - outstanding_amount - credit_note_amount
					row += [invoiced_amount, paid_amt, credit_note_amount, outstanding_amount]

					# ageing data
					entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
					row += get_ageing_data(cint(self.filters.range1), cint(self.filters.range2),
						cint(self.filters.range3), self.age_as_on, entry_date, outstanding_amount)

					# issue 6371-Ageing buckets should not have amounts if due date is not reached
					if self.filters.ageing_based_on == "Due Date" \
							and getdate(due_date) > getdate(self.filters.report_date):
						row[-1]=row[-2]=row[-3]=row[-4]=0

					if self.filters.get(scrub(args.get("party_type"))):
						row.append(gle.account_currency)
					else:
						row.append(company_currency)

					# customer territory / supplier type
					if args.get("party_type") == "Customer":
						row += [self.get_territory(gle.party), self.get_customer_group(gle.party)]
					if args.get("party_type") == "Supplier":
						row += [self.get_supplier_type(gle.party)]

					row.append(gle.remarks)

					data.append(row)

		return data
Example #8
0
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2
		dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		dn_details = get_dn_details(args.get("party_type"))
		voucher_details = self.get_voucher_details(args.get("party_type"), dn_details)

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		if not self.filters.get("company"):
			self.filters["company"] = frappe.db.get_single_value('Global Defaults', 'default_company')

		company_currency = frappe.db.get_value("Company", self.filters.get("company"), "default_currency")

		return_entries = self.get_return_entries(args.get("party_type"))

		data = []
		pdc_details = get_pdc_details(args.get("party_type"), self.filters.report_date)

		for gle in self.get_entries_till(self.filters.report_date, args.get("party_type")):
			if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
				outstanding_amount, credit_note_amount = self.get_outstanding_amount(gle,
					self.filters.report_date, dr_or_cr, return_entries, currency_precision)
				if abs(outstanding_amount) > 0.1/10**currency_precision:
					row = [gle.posting_date, gle.party]

					# customer / supplier name
					if party_naming_by == "Naming Series":
						row += [self.get_party_name(gle.party_type, gle.party)]

					# get due date
					due_date = voucher_details.get(gle.voucher_no, {}).get("due_date", "")
					bill_date = voucher_details.get(gle.voucher_no, {}).get("bill_date", "")

					row += [gle.voucher_type, gle.voucher_no, due_date]

					# get supplier bill details
					if args.get("party_type") == "Supplier":
						row += [
							voucher_details.get(gle.voucher_no, {}).get("bill_no", ""),
							voucher_details.get(gle.voucher_no, {}).get("bill_date", "")
						]

					# invoiced and paid amounts
					invoiced_amount = gle.get(dr_or_cr) if (gle.get(dr_or_cr) > 0) else 0
					paid_amt = invoiced_amount - outstanding_amount - credit_note_amount
					row += [invoiced_amount, paid_amt, credit_note_amount, outstanding_amount]

					# ageing data
					if self.filters.ageing_based_on == "Due Date":
						entry_date = due_date 
					elif self.filters.ageing_based_on == "Supplier Invoice Date": 
						entry_date = bill_date    
					else:
						entry_date = gle.posting_date
					row += get_ageing_data(cint(self.filters.range1), cint(self.filters.range2),
						cint(self.filters.range3), self.age_as_on, entry_date, outstanding_amount)


					# issue 6371-Ageing buckets should not have amounts if due date is not reached
					if self.filters.ageing_based_on == "Due Date" \
							and getdate(due_date) > getdate(self.filters.report_date):
						row[-1]=row[-2]=row[-3]=row[-4]=0

					if self.filters.ageing_based_on == "Supplier Invoice Date" \
							and getdate(bill_date) > getdate(self.filters.report_date):
						row[-1]=row[-2]=row[-3]=row[-4]=0

					if self.filters.get(scrub(args.get("party_type"))):
						row.append(gle.account_currency)
					else:
						row.append(company_currency)

					pdc = pdc_details.get((gle.voucher_no, gle.party), {})

					remaining_balance = outstanding_amount - flt(pdc.get("pdc_amount"))
					row += [pdc.get("pdc_date"), pdc.get("pdc_ref"),
						flt(pdc.get("pdc_amount")), remaining_balance]

					if args.get('party_type') == 'Customer':
						# customer LPO
						row += [voucher_details.get(gle.voucher_no, {}).get("po_no")]

						# Delivery Note
						row += [voucher_details.get(gle.voucher_no, {}).get("delivery_note")]

					# customer territory / supplier type
					if args.get("party_type") == "Customer":
						row += [self.get_territory(gle.party), self.get_customer_group(gle.party)]
					if args.get("party_type") == "Supplier":
						row += [self.get_supplier_type(gle.party)]

					row.append(gle.remarks)
					data.append(row)

		return data
    def get_data(self, party_naming_by, args):
        from erpnext.accounts.utils import get_currency_precision
        currency_precision = get_currency_precision() or 2
        dr_or_cr = "debit" if args.get(
            "party_type") == "Customer" else "credit"

        voucher_details = self.get_voucher_details(args.get("party_type"))

        future_vouchers = self.get_entries_after(self.filters.report_date,
                                                 args.get("party_type"))

        company_currency = frappe.db.get_value("Company",
                                               self.filters.get("company"),
                                               "default_currency")

        data = []
        for gle in self.get_entries_till(self.filters.report_date,
                                         args.get("party_type")):
            if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
                outstanding_amount = self.get_outstanding_amount(
                    gle, self.filters.report_date, dr_or_cr)
                if abs(outstanding_amount) > 0.1 / 10**currency_precision:

                    row = [gle.posting_date, gle.party]

                    # customer / supplier name
                    if party_naming_by == "Naming Series":
                        row += [self.get_party_name(gle.party_type, gle.party)]

                    # get due date
                    due_date = voucher_details.get(gle.voucher_no,
                                                   {}).get("due_date", "")

                    row += [gle.voucher_type, gle.voucher_no, due_date]

                    # get supplier bill details
                    if args.get("party_type") == "Supplier":
                        row += [
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_no", ""),
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_date", "")
                        ]

                    # invoiced and paid amounts
                    invoiced_amount = gle.get(dr_or_cr) if (
                        gle.get(dr_or_cr) > 0) else 0
                    paid_amt = invoiced_amount - outstanding_amount
                    row += [invoiced_amount, paid_amt, outstanding_amount]

                    # ageing data
                    entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
                    row += get_ageing_data(cint(self.filters.range1),
                                           cint(self.filters.range2),
                                           cint(self.filters.range3),
                                           self.age_as_on, entry_date,
                                           outstanding_amount)

                    if self.filters.get(scrub(args.get("party_type"))):
                        row.append(gle.account_currency)
                    else:
                        row.append(company_currency)

                    # customer territory / supplier type
                    if args.get("party_type") == "Customer":
                        row += [self.get_territory(gle.party)]
                    if args.get("party_type") == "Supplier":
                        row += [self.get_supplier_type(gle.party)]

                    row.append(gle.remarks)
                    data.append(row)

        return data
    def get_data(self, party_naming_by, args):
        from erpnext.accounts.utils import get_currency_precision
        currency_precision = get_currency_precision() or 2
        dr_or_cr = "debit" if args.get(
            "party_type") == "Customer" else "credit"

        voucher_details = self.get_voucher_details(args.get("party_type"))

        future_vouchers = self.get_entries_after(self.filters.report_date,
                                                 args.get("party_type"))

        if not self.filters.get("company"):
            self.filters["company"] = frappe.db.get_single_value(
                'Global Defaults', 'default_company')

        company_currency = frappe.db.get_value("Company",
                                               self.filters.get("company"),
                                               "default_currency")

        data = []
        for gle in self.get_entries_till(self.filters.report_date,
                                         args.get("party_type")):
            if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
                outstanding_amount = flt(
                    self.get_outstanding_amount(gle, self.filters.report_date,
                                                dr_or_cr), currency_precision)

                if abs(outstanding_amount) > 0.1 / 10**currency_precision:
                    row = [gle.posting_date, gle.party]

                    # customer / supplier name
                    if party_naming_by == "Naming Series":
                        row += [self.get_party_name(gle.party_type, gle.party)]

                    # get due date
                    due_date = voucher_details.get(gle.voucher_no,
                                                   {}).get("due_date", "")

                    row += [gle.voucher_type, gle.voucher_no, due_date]

                    # get supplier bill details
                    if args.get("party_type") == "Supplier":
                        row += [
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_no", ""),
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_date", "")
                        ]

                    # invoiced and paid amounts
                    invoiced_amount = gle.get(dr_or_cr) if (
                        gle.get(dr_or_cr) > 0) else 0
                    paid_amt = invoiced_amount - outstanding_amount
                    row += [invoiced_amount, paid_amt, outstanding_amount]

                    # ageing data
                    entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
                    row += get_ageing_data(cint(self.filters.range1),
                                           cint(self.filters.range2),
                                           cint(self.filters.range3),
                                           self.age_as_on, entry_date,
                                           outstanding_amount)

                    # issue 6371-Ageing buckets should not have amounts if due date is not reached
                    if self.filters.ageing_based_on == "Due Date" and getdate(
                            due_date) > getdate(self.filters.report_date):
                        row[-1] = row[-2] = row[-3] = row[-4] = 0

                    if self.filters.get(scrub(args.get("party_type"))):
                        row.append(gle.account_currency)
                    else:
                        row.append(company_currency)

                    # customer territory / supplier type
                    if args.get("party_type") == "Customer":
                        row += [self.get_territory(gle.party)]

                        #append Sales_team
                        s_t = get_sales_team_data(gle.voucher_no)
                        ws = []
                        for k in s_t:
                            ws.append(k.get("sales_person"))
                        row += [','.join(ws)]
                    if args.get("party_type") == "Supplier":
                        row += [self.get_supplier_type(gle.party)]

                    row.append(gle.remarks)
                    print("3", row)
                    data.append(row)

        return data
Example #11
0
    def get_data(self, party_naming_by, args):
        from erpnext.accounts.utils import get_currency_precision
        self.currency_precision = get_currency_precision() or 2
        self.dr_or_cr = "debit" if args.get(
            "party_type") == "Customer" else "credit"

        future_vouchers = self.get_entries_after(self.filters.report_date,
                                                 args.get("party_type"))

        if not self.filters.get("company"):
            self.filters["company"] = frappe.db.get_single_value(
                'Global Defaults', 'default_company')

        self.company_currency = frappe.get_cached_value(
            'Company', self.filters.get("company"), "default_currency")

        return_entries = self.get_return_entries(args.get("party_type"))

        data = []
        self.pdc_details = get_pdc_details(args.get("party_type"),
                                           self.filters.report_date)
        gl_entries_data = self.get_entries_till(self.filters.report_date,
                                                args.get("party_type"))

        if gl_entries_data:
            voucher_nos = [d.voucher_no for d in gl_entries_data] or []
            dn_details = get_dn_details(args.get("party_type"), voucher_nos)
            self.voucher_details = get_voucher_details(args.get("party_type"),
                                                       voucher_nos, dn_details)

        if self.filters.based_on_payment_terms and gl_entries_data:
            self.payment_term_map = self.get_payment_term_detail(voucher_nos)

        for gle in gl_entries_data:
            if self.is_receivable_or_payable(gle, self.dr_or_cr,
                                             future_vouchers, return_entries):
                outstanding_amount, credit_note_amount, payment_amount = self.get_outstanding_amount(
                    gle, self.filters.report_date, self.dr_or_cr,
                    return_entries)
                temp_outstanding_amt = outstanding_amount
                temp_credit_note_amt = credit_note_amount

                if abs(outstanding_amount) > 0.1 / 10**self.currency_precision:
                    if self.filters.based_on_payment_terms and self.payment_term_map.get(
                            gle.voucher_no):
                        for d in self.payment_term_map.get(gle.voucher_no):
                            # Allocate payment amount based on payment terms(FIFO order)
                            payment_amount, d.payment_amount = self.allocate_based_on_fifo(
                                payment_amount, d.payment_term_amount)

                            term_outstanding_amount = d.payment_term_amount - d.payment_amount

                            # Allocate credit note based on payment terms(FIFO order)
                            credit_note_amount, d.credit_note_amount = self.allocate_based_on_fifo(
                                credit_note_amount, term_outstanding_amount)

                            term_outstanding_amount -= d.credit_note_amount

                            row_outstanding = term_outstanding_amount
                            # Allocate PDC based on payment terms(FIFO order)
                            d.pdc_details, d.pdc_amount = self.allocate_pdc_amount_in_fifo(
                                gle, row_outstanding)

                            if term_outstanding_amount > 0:
                                row = self.prepare_row(
                                    party_naming_by, args, gle,
                                    term_outstanding_amount,
                                    d.credit_note_amount, d.due_date,
                                    d.payment_amount, d.payment_term_amount,
                                    d.description, d.pdc_amount, d.pdc_details)
                                data.append(row)

                        if credit_note_amount:
                            row = self.prepare_row_without_payment_terms(
                                party_naming_by, args, gle,
                                temp_outstanding_amt, temp_credit_note_amt)
                            data.append(row)

                    else:
                        row = self.prepare_row_without_payment_terms(
                            party_naming_by, args, gle, outstanding_amount,
                            credit_note_amount)
                        data.append(row)
        return data
Example #12
0
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		currency_precision = get_currency_precision() or 2
		dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		if not self.filters.get("company"):
			self.filters["company"] = frappe.db.get_single_value('Global Defaults', 'default_company')

		company_currency = frappe.db.get_value("Company", self.filters.get("company"), "default_currency")

		return_entries = self.get_return_entries(args.get("party_type"))

		data = []
		pdc_details = get_pdc_details(args.get("party_type"), self.filters.report_date)
		gl_entries_data = self.get_entries_till(self.filters.report_date, args.get("party_type"))

		if gl_entries_data:
			voucher_nos = [d.voucher_no for d in gl_entries_data] or []
			dn_details = get_dn_details(args.get("party_type"), voucher_nos)
			voucher_details = get_voucher_details(args.get("party_type"), voucher_nos, dn_details)

		for gle in gl_entries_data:
			if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
				outstanding_amount, credit_note_amount = self.get_outstanding_amount(gle,
					self.filters.report_date, dr_or_cr, return_entries, currency_precision)
				if abs(outstanding_amount) > 0.1/10**currency_precision:
					row = [gle.posting_date, gle.party]

					# customer / supplier name
					if party_naming_by == "Naming Series":
						row += [self.get_party_name(gle.party_type, gle.party)]

					# get due date
					due_date = voucher_details.get(gle.voucher_no, {}).get("due_date", "")
					bill_date = voucher_details.get(gle.voucher_no, {}).get("bill_date", "")

					row += [gle.voucher_type, gle.voucher_no, due_date]

					# get supplier bill details
					if args.get("party_type") == "Supplier":
						row += [
							voucher_details.get(gle.voucher_no, {}).get("bill_no", ""),
							voucher_details.get(gle.voucher_no, {}).get("bill_date", "")
						]

					# invoiced and paid amounts
					invoiced_amount = gle.get(dr_or_cr) if (gle.get(dr_or_cr) > 0) else 0
					paid_amt = invoiced_amount - outstanding_amount - credit_note_amount
					row += [invoiced_amount, paid_amt, credit_note_amount, outstanding_amount]

					# ageing data
					if self.filters.ageing_based_on == "Due Date":
						entry_date = due_date 
					elif self.filters.ageing_based_on == "Supplier Invoice Date": 
						entry_date = bill_date
					else:
						entry_date = gle.posting_date
					row += get_ageing_data(cint(self.filters.range1), cint(self.filters.range2),
						cint(self.filters.range3), self.age_as_on, entry_date, outstanding_amount)


					# issue 6371-Ageing buckets should not have amounts if due date is not reached
					if self.filters.ageing_based_on == "Due Date" \
							and getdate(due_date) > getdate(self.filters.report_date):
						row[-1]=row[-2]=row[-3]=row[-4]=0

					if self.filters.ageing_based_on == "Supplier Invoice Date" \
							and getdate(bill_date) > getdate(self.filters.report_date):
						row[-1]=row[-2]=row[-3]=row[-4]=0

					if self.filters.get(scrub(args.get("party_type"))):
						row.append(gle.account_currency)
					else:
						row.append(company_currency)

					pdc = pdc_details.get((gle.voucher_no, gle.party), {})

					remaining_balance = outstanding_amount - flt(pdc.get("pdc_amount"))
					row += [pdc.get("pdc_date"), pdc.get("pdc_ref"),
						flt(pdc.get("pdc_amount")), remaining_balance]

					if args.get('party_type') == 'Customer':
						# customer LPO
						row += [voucher_details.get(gle.voucher_no, {}).get("po_no")]

						# Delivery Note
						row += [voucher_details.get(gle.voucher_no, {}).get("delivery_note")]

					# customer territory / supplier type
					if args.get("party_type") == "Customer":
						row += [self.get_territory(gle.party), self.get_customer_group(gle.party)]
					if args.get("party_type") == "Supplier":
						row += [self.get_supplier_type(gle.party)]

					row.append(gle.remarks)
					data.append(row)

		return data
Example #13
0
	def get_data(self, party_naming_by, args):
		from erpnext.accounts.utils import get_currency_precision
		self.currency_precision = get_currency_precision() or 2
		self.dr_or_cr = "debit" if args.get("party_type") == "Customer" else "credit"

		future_vouchers = self.get_entries_after(self.filters.report_date, args.get("party_type"))

		if not self.filters.get("company"):
			self.filters["company"] = frappe.db.get_single_value('Global Defaults', 'default_company')

		self.company_currency = frappe.get_cached_value('Company',  self.filters.get("company"), "default_currency")

		return_entries = self.get_return_entries(args.get("party_type"))

		data = []
		self.pdc_details = get_pdc_details(args.get("party_type"), self.filters.report_date)
		gl_entries_data = self.get_entries_till(self.filters.report_date, args.get("party_type"))

		if gl_entries_data:
			voucher_nos = [d.voucher_no for d in gl_entries_data] or []
			dn_details = get_dn_details(args.get("party_type"), voucher_nos)
			self.voucher_details = get_voucher_details(args.get("party_type"), voucher_nos, dn_details)

		if self.filters.based_on_payment_terms and gl_entries_data:
			self.payment_term_map = self.get_payment_term_detail(voucher_nos)

		for gle in gl_entries_data:
			if self.is_receivable_or_payable(gle, self.dr_or_cr, future_vouchers, return_entries):
				outstanding_amount, credit_note_amount, payment_amount = self.get_outstanding_amount(
					gle,self.filters.report_date, self.dr_or_cr, return_entries)
				temp_outstanding_amt = outstanding_amount
				temp_credit_note_amt = credit_note_amount

				if abs(outstanding_amount) > 0.1/10**self.currency_precision:
					if self.filters.based_on_payment_terms and self.payment_term_map.get(gle.voucher_no):
						for d in self.payment_term_map.get(gle.voucher_no):
							# Allocate payment amount based on payment terms(FIFO order)
							payment_amount, d.payment_amount = self.allocate_based_on_fifo(payment_amount, d.payment_term_amount)

							term_outstanding_amount = d.payment_term_amount - d.payment_amount

							# Allocate credit note based on payment terms(FIFO order)
							credit_note_amount, d.credit_note_amount = self.allocate_based_on_fifo(credit_note_amount, term_outstanding_amount)

							term_outstanding_amount -= d.credit_note_amount

							row_outstanding = term_outstanding_amount
							# Allocate PDC based on payment terms(FIFO order)
							d.pdc_details, d.pdc_amount = self.allocate_pdc_amount_in_fifo(gle, row_outstanding)

							if term_outstanding_amount > 0:
								row = self.prepare_row(party_naming_by, args, gle, term_outstanding_amount,
									d.credit_note_amount, d.due_date, d.payment_amount , d.payment_term_amount,
									d.description, d.pdc_amount, d.pdc_details)
								data.append(row)

						if credit_note_amount:
							row = self.prepare_row_without_payment_terms(party_naming_by, args, gle, temp_outstanding_amt,
								temp_credit_note_amt)
							data.append(row)

					else:
						row = self.prepare_row_without_payment_terms(party_naming_by, args, gle, outstanding_amount,
							credit_note_amount)
						data.append(row)
		return data
    def get_data(self, party_naming_by, args):
        from erpnext.accounts.utils import get_currency_precision
        currency_precision = get_currency_precision() or 2
        dr_or_cr = "debit" if args.get(
            "party_type") == "Customer" else "credit"

        voucher_details = self.get_voucher_details(args.get("party_type"))

        future_vouchers = self.get_entries_after(self.filters.report_date,
                                                 args.get("party_type"))

        if not self.filters.get("company"):
            self.filters["company"] = frappe.db.get_single_value(
                'Global Defaults', 'default_company')

        company_currency = frappe.db.get_value("Company",
                                               self.filters.get("company"),
                                               "default_currency")

        return_entries = self.get_return_entries(args.get("party_type"))

        data = []
        invoice_type = ""
        business_unit = ""
        division = ""
        for gle in self.get_entries_till(self.filters.report_date,
                                         args.get("party_type")):
            if self.is_receivable_or_payable(gle, dr_or_cr, future_vouchers):
                outstanding_amount, credit_note_amount = self.get_outstanding_amount(
                    gle, self.filters.report_date, dr_or_cr, return_entries,
                    currency_precision)
                if abs(outstanding_amount) > 0.1 / 10**currency_precision:
                    row = [gle.posting_date, gle.party]

                    # customer / supplier name
                    if party_naming_by == "Naming Series":
                        row += [self.get_party_name(gle.party_type, gle.party)]
                    # get due date
                    due_date = voucher_details.get(gle.voucher_no,
                                                   {}).get("due_date", "")

                    # get_payment_type
                    if gle.voucher_type == 'Sales Invoice':
                        invoice_type = frappe.db.get_value(
                            "Sales Invoice", gle.voucher_no, "invoice_type")
                        business_unit = frappe.db.get_value(
                            "Sales Invoice", gle.voucher_no, "business_unit")
                        division = frappe.db.get_value("Sales Invoice",
                                                       gle.voucher_no,
                                                       "division")

                    if gle.voucher_type == 'Purchase Invoice':
                        business_unit = frappe.db.get_value(
                            "Purchase Invoice", gle.voucher_no,
                            "business_unit")
                        division = frappe.db.get_value("Purchase Invoice",
                                                       gle.voucher_no,
                                                       "division")

                    if gle.voucher_type == 'Journal Entry':
                        invoice_type = frappe.db.get_value(
                            "Journal Entry", gle.voucher_no, "invoice_type")
                        business_unit = frappe.db.get_value(
                            "Journal Entry", gle.voucher_no, "business_unit")
                        division = frappe.db.get_value("Journal Entry",
                                                       gle.voucher_no,
                                                       "division")

                    if gle.voucher_type == 'Payment Entry':
                        invoice_type = frappe.db.get_value(
                            "Payment Entry", gle.voucher_no, "invoice_type")
                        business_unit = frappe.db.get_value(
                            "Payment Entry", gle.voucher_no, "business_unit")
                        division = frappe.db.get_value("Payment Entry",
                                                       gle.voucher_no,
                                                       "division")

                    item_name = []
                    item_code = []
                    sii = frappe.get_all("Sales Invoice Item",
                                         fields=["item_name", "item_code"],
                                         filters={"parent": gle.voucher_no},
                                         limit_page_length=0)

                    for si in sii:
                        # frappe.errprint(si)
                        item_code.append(si["item_code"])
                    for si in sii:
                        item_name.append(si["item_name"])

                    item_name = "/".join(item_name)
                    item_code = "/".join(item_code)

                    row += [
                        gle.voucher_type, invoice_type or '', item_code or '',
                        item_name or '', business_unit or '', division or '',
                        gle.voucher_no, due_date
                    ]
                    if args.get("party_type") == "Supplier":
                        row += [
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_no", ""),
                            voucher_details.get(gle.voucher_no,
                                                {}).get("bill_date", "")
                        ]

                    # invoiced and paid amounts
                    invoiced_amount = gle.get(dr_or_cr) if (
                        gle.get(dr_or_cr) > 0) else 0
                    paid_amt = invoiced_amount - outstanding_amount - credit_note_amount
                    row += [
                        invoiced_amount, paid_amt, credit_note_amount,
                        outstanding_amount
                    ]

                    # ageing data
                    entry_date = due_date if self.filters.ageing_based_on == "Due Date" else gle.posting_date
                    row += get_ageing_data(cint(self.filters.range1),
                                           cint(self.filters.range2),
                                           cint(self.filters.range3),
                                           self.age_as_on, entry_date,
                                           outstanding_amount)

                    # issue 6371-Ageing buckets should not have amounts if due
                    # date is not reached
                    if self.filters.ageing_based_on == "Due Date" \
                            and getdate(due_date) > getdate(self.filters.report_date):
                        row[-1] = row[-2] = row[-3] = row[-4] = 0

                    if self.filters.get(scrub(args.get("party_type"))):
                        row.append(gle.account_currency)
                    else:
                        row.append(company_currency)

                    # customer territory / supplier type
                    if args.get("party_type") == "Customer":
                        row += [
                            self.get_territory(gle.party),
                            self.get_customer_group(gle.party)
                        ]
                    if args.get("party_type") == "Supplier":
                        row += [self.get_supplier_type(gle.party)]

                    row.append(gle.remarks)
                    data.append(row)

        return data