def invalid_batch_qtys(items):
get_qtys = compose(partial(valmap, sum_by("qty")),
partial(groupby, "item_code"))
get_si_items = compose(get_qtys, partial(map, lambda x: x.as_dict()),
_filter_batch_items)
get_batch_items = compose(get_qtys, json.loads)
return get_si_items(items) != get_batch_items(batches)
def make_aggregator(start, end):
return compose(
sum_by("amount"),
lambda x: filter(
lambda row: row.branch == x and (start <= row.posting_date <= end),
payments,
),
partial(get, "branch"),
)
def _get_mop_collections(payments, end_date):
get_sum_today = compose(
sum_by("amount"),
lambda x: filter(
lambda row: row.mode_of_payment == x and row.posting_date == end_date,
payments,
),
partial(get, "mop"),
)
get_sum_mtd = compose(
sum_by("amount"),
lambda x: filter(lambda row: row.mode_of_payment == x, payments),
partial(get, "mop"),
)
return map_resolved(
lambda x: merge(
x, {"collected_today": get_sum_today(x), "collected_mtd": get_sum_mtd(x)}
),
frappe.get_all("Mode of Payment", fields=["name AS mop"]),
)
def _get_mop_collections(payments, yesterday):
get_sum_today = compose(
sum_by("amount"),
lambda x: filter(
lambda row: row.mode_of_payment == x and row.posting_date == yesterday,
payments,
),
partial(get, "mop"),
)
return mapf(
lambda x: merge(x, {"collected_today": get_sum_today(x)}),
frappe.get_all("Mode of Payment", fields=["name AS mop"]),
)
def _get_branch_collections(payments, end_date):
get_sum_today = compose(
sum_by("amount"),
lambda x: filter(
lambda row: row.branch == x and row.posting_date == end_date, payments
),
partial(get, "branch"),
)
get_sum_mtd = compose(
sum_by("amount"),
lambda x: filter(lambda row: row.branch == x, payments),
partial(get, "branch"),
)
get_percent = excepts(ZeroDivisionError, lambda x, y: x / y * 100, lambda __: 0)
def set_amounts(x):
monthly_target = get("monthly_target", x, 0)
collected_mtd = get_sum_mtd(x)
return {
"collected_today": get_sum_today(x),
"half_monthly_target": monthly_target / 2,
"half_monthly_target_percent": get_percent(
collected_mtd, monthly_target / 2
),
"collected_mtd": collected_mtd,
"monthly_target_remaining": monthly_target - collected_mtd,
"monthly_target_percent": get_percent(collected_mtd, monthly_target),
}
return map_resolved(
lambda x: merge(x, set_amounts(x)),
frappe.get_all(
"Branch",
fields=["name AS branch", "os_target AS monthly_target"],
filters={"disabled": 0},
),
)
def _set_qty(bins):
grouped = groupby("item_code", bins)
get_total = sum_by("qty")
def fn(item):
branches = grouped.get(item.get("item_code"))
return (merge(
item,
{x.get("branch"): x.get("qty")
for x in branches},
{"total_qty": get_total(branches)},
) if branches else item)
return fn
def _set_payments(payments):
mop_map = compose(
partial(valmap, sum_by("amount")),
partial(groupby, ("mode_of_payment")),
partial(filter, lambda x: x.get("amount") is not None),
)
payments_grouped = compose(partial(valmap, mop_map),
partial(groupby, "posting_date"))(payments)
def fn(row):
mops = payments_grouped[row.get("posting_date")]
return merge(row, mops, {"total_collected": sum(mops.values())})
return fn
def _get_grouped_mop_collections(payments, yesterday):
get_sum_today = compose(
sum_by("amount"),
lambda x: filter(
lambda row: row.mode_of_payment in x and row.posting_date == yesterday,
payments,
),
lambda x: x.split("\n"),
partial(get, "mops", default=""),
)
return [
merge(x, {"collected_today": get_sum_today(x)})
for x in frappe.get_all(
"Email Alerts Grouped MOP", fields=["group_name", "mops"]
)
]
def set_missing_fields(self):
for item in self.items:
item.amount = flt(item.qty) * flt(item.basic_rate)
item.valuation_rate = item.amount / flt(item.qty)
self.total_value = sum_by("amount")(self.items)
self.total_qty = sum_by("qty")(self.items)
def set_report_details(self):
args = merge(
pick(["user", "pos_profile", "company"], self.as_dict()),
{
"start_time": self.start_time or now(),
"end_time": self.end_time or now(),
},
)
sales, returns = _get_invoices(args)
sales_payments, returns_payments, collection_payments = _get_payments(
args)
taxes = _get_taxes(args)
make_invoice = partial(
pick, ["invoice", "total_qty", "grand_total", "paid_amount"])
make_payment = partial(pick, ["mode_of_payment", "amount"])
make_tax = partial(pick, ["rate", "tax_amount"])
mops = compose(unique, partial(pluck, "mode_of_payment"))
def get_mop_amount(mode_of_payment, payments=[]):
return compose(
partial(get, "amount"),
excepts(StopIteration, first, lambda x: {"amount": 0}),
partial(filter,
lambda x: x.get("mode_of_payment") == mode_of_payment),
)(payments)
get_cash = partial(get_mop_amount, "Cash")
get_sales_amount = partial(get_mop_amount, payments=sales_payments)
get_returns_amount = partial(get_mop_amount, payments=returns_payments)
get_collection_amount = partial(get_mop_amount,
payments=collection_payments)
def make_payment(mode_of_payment):
sales_amount = get_sales_amount(mode_of_payment)
returns_amount = get_returns_amount(mode_of_payment)
collection_amount = get_collection_amount(mode_of_payment)
return {
"mode_of_payment": mode_of_payment,
"sales_amount": sales_amount,
"returns_amount": returns_amount,
"collection_amount": collection_amount,
"total_amount":
sales_amount + returns_amount + collection_amount,
}
sum_by_total = sum_by("total")
sum_by_net = sum_by("net_total")
sum_by_discount = compose(neg, sum_by("discount_amount"))
sum_by_taxes = sum_by("tax_amount")
sum_by_grand = sum_by("grand_total")
self.cash_sales = get_cash(sales_payments)
self.cash_returns = get_cash(returns_payments)
self.cash_pe_received = get_cash(collection_payments)
self.sales__total = sum_by_total(sales) - sum_by_total(returns)
self.total__discount_amount = sum_by_discount(sales) + sum_by_discount(
returns)
self.returns__net_total = sum_by_net(returns)
self.total__net_total = sum_by_net(sales + returns)
self.total__total_taxes_and_charges = sum_by_taxes(taxes)
self.total__grand_total = sum_by_grand(sales) + sum_by_grand(returns)
self.sales = []
for invoice in sales:
self.append("sales", make_invoice(invoice))
self.returns = []
for invoice in returns:
self.append("returns", make_invoice(invoice))
self.payments = []
for payment in mops(sales_payments + returns_payments +
collection_payments):
self.append("payments", make_payment(payment))
self.taxes = []
for tax in taxes:
self.append("taxes", make_tax(tax))
self.total_collection = sum_by("total_amount")(self.payments)
def si_deliverable(items):
return sum_by("qty")(items) > sum_by("delivered_qty")(items)
