def get_current_tax_fraction(self, tax, item_tax_map): """ Get tax fraction for calculating tax exclusive amount from tax inclusive amount """ current_tax_fraction = 0 if cint(tax.included_in_print_rate): tax_rate = self._get_tax_rate(tax, item_tax_map) if tax.charge_type == "On Net Total": current_tax_fraction = tax_rate / 100.0 elif tax.charge_type == "On Previous Row Amount": current_tax_fraction = (tax_rate / 100.0) * \ self.tax_doclist[cint(tax.row_id) - 1]\ .tax_fraction_for_current_item elif tax.charge_type == "On Previous Row Total": current_tax_fraction = (tax_rate / 100.0) * \ self.tax_doclist[cint(tax.row_id) - 1]\ .grand_total_fraction_for_current_item # print tax.account_head, tax_rate, current_tax_fraction return current_tax_fraction
def validate_return_reference_doc(self):
"""validate item with reference doc"""
ref = get_return_doclist_and_details(self.doc.fields)
if ref.doclist:
# validate docstatus
if ref.doclist[0].docstatus != 1:
webnotes.msgprint(
_(ref.doclist[0].doctype) + ' "' + ref.doclist[0].name + '": ' + _("Status should be Submitted"),
raise_exception=webnotes.InvalidStatusError,
)
# update stock check
if ref.doclist[0].doctype == "Sales Invoice" and (
cint(ref.doclist[0].is_pos) != 1 or cint(ref.doclist[0].update_stock) != 1
):
webnotes.msgprint(
_(ref.doclist[0].doctype)
+ ' "'
+ ref.doclist[0].name
+ '": '
+ _("Is POS and Update Stock should be checked."),
raise_exception=NotUpdateStockError,
)
# posting date check
ref_posting_datetime = "%s %s" % (
cstr(ref.doclist[0].posting_date),
cstr(ref.doclist[0].posting_time) or "00:00:00",
)
this_posting_datetime = "%s %s" % (cstr(self.doc.posting_date), cstr(self.doc.posting_time))
if this_posting_datetime < ref_posting_datetime:
from webnotes.utils.dateutils import datetime_in_user_format
webnotes.msgprint(
_("Posting Date Time cannot be before") + ": " + datetime_in_user_format(ref_posting_datetime),
raise_exception=True,
)
stock_items = get_stock_items_for_return(ref.doclist, ref.parentfields)
already_returned_item_qty = self.get_already_returned_item_qty(ref.fieldname)
for item in self.doclist.get({"parentfield": "mtn_details"}):
# validate if item exists in the ref doclist and that it is a stock item
if item.item_code not in stock_items:
msgprint(
_("Item")
+ ': "'
+ item.item_code
+ _('" does not exist in ')
+ ref.doclist[0].doctype
+ ": "
+ ref.doclist[0].name,
raise_exception=webnotes.DoesNotExistError,
)
# validate quantity <= ref item's qty - qty already returned
ref_item = ref.doclist.getone({"item_code": item.item_code})
returnable_qty = ref_item.qty - flt(already_returned_item_qty.get(item.item_code))
self.validate_value("transfer_qty", "<=", returnable_qty, item, raise_exception=StockOverReturnError)
def validate(self):
self.so_dn_required()
self.validate_proj_cust()
sales_com_obj = get_obj('Sales Common')
sales_com_obj.check_stop_sales_order(self)
sales_com_obj.check_active_sales_items(self)
sales_com_obj.check_conversion_rate(self)
sales_com_obj.validate_max_discount(self, 'entries') #verify whether rate is not greater than tolerance
sales_com_obj.get_allocated_sum(self) # this is to verify that the allocated % of sales persons is 100%
sales_com_obj.validate_fiscal_year(self.doc.fiscal_year,self.doc.posting_date,'Posting Date')
self.validate_customer()
self.validate_customer_account()
self.validate_debit_acc()
self.validate_fixed_asset_account()
self.add_remarks()
if cint(self.doc.is_pos):
self.validate_pos()
self.validate_write_off_account()
if cint(self.doc.update_stock):
sl = get_obj('Stock Ledger')
sl.validate_serial_no(self, 'entries')
sl.validate_serial_no(self, 'packing_details')
self.validate_item_code()
self.update_current_stock()
self.validate_delivery_note()
self.set_in_words()
if not self.doc.is_opening:
self.doc.is_opening = 'No'
self.set_aging_date()
self.clear_advances()
self.set_against_income_account()
self.validate_c_form()
self.validate_recurring_invoice()
def on_update(self):
# Set default warehouse from pos setting
if cint(self.doc.is_pos) == 1:
if cint(self.doc.update_stock) == 1:
w = self.get_warehouse()
if w:
for d in getlist(self.doclist, 'entries'):
if not d.warehouse:
d.warehouse = cstr(w)
self.make_packing_list()
else:
self.doclist = self.doc.clear_table(self.doclist, 'packing_details')
if flt(self.doc.paid_amount) == 0:
if self.doc.cash_bank_account:
webnotes.conn.set(self.doc, 'paid_amount',
(flt(self.doc.grand_total) - flt(self.doc.write_off_amount)))
else:
# show message that the amount is not paid
webnotes.conn.set(self.doc,'paid_amount',0)
webnotes.msgprint("Note: Payment Entry will not be created since 'Cash/Bank Account' was not specified.")
else:
self.doclist = self.doc.clear_table(self.doclist, 'packing_details')
webnotes.conn.set(self.doc,'paid_amount',0)
webnotes.conn.set(self.doc, 'outstanding_amount',
flt(self.doc.grand_total) - flt(self.doc.total_advance) -
flt(self.doc.paid_amount) - flt(self.doc.write_off_amount))
def prepare(self):
if not self.doc.font_size:
self.doc.font_size = '13px'
self.doc.small_font_size = cstr(cint(self.doc.font_size[:-2])-2) + 'px'
self.doc.page_border = cint(self.doc.page_border)
fonts = []
if self.doc.google_web_font_for_heading:
fonts.append(self.doc.google_web_font_for_heading)
if self.doc.google_web_font_for_text:
fonts.append(self.doc.google_web_font_for_text)
fonts = list(set(fonts))
if self.doc.heading_text_as:
self.doc.heading_text_style = {
"UPPERCASE": "uppercase",
"Title Case":"capitalize",
"lowercase": "lowercase"
}.get(self.doc.heading_text_as) or ""
self.doc.at_import = ""
for f in fonts:
self.doc.at_import += "\n@import url(https://fonts.googleapis.com/css?family=%s:400,700);" % f.replace(" ", "+")
def calculate_ded_total(self):
self.doc.total_deduction = 0
qry=webnotes.conn.sql(" select name from `tabEmployee Loan` where employee_id=%s", self.doc.employee ,as_list=1)
#webnotes.errprint(qry)
r=0
if len(qry)!=0:
qr=webnotes.conn.sql("select date_of_installment from `tabLoan Installment Details` where parent=%s",qry[0][0],as_list=1)
for i in qr:
t=getdate(i[0]).month
if t == cint(self.doc.month):
q=webnotes.conn.sql("select amount_to_be_paid from `tabLoan Installment Details` where date_of_installment=%s and parent=%s",(getdate(i[0]),qry[0][0]),as_list=1)
w=webnotes.conn.sql("Update `tabLoan Installment Details` set status='Paid' where date_of_installment=%s",getdate(i[0]))
#webnotes.errprint(q)
r=q[0][0]
self.doc.loan_amount=r
m=0.0
for d in getlist(self.doclist, 'deduction_details'):
if cint(d.d_depends_on_lwp) == 1:
d.d_modified_amount = _round(flt(d.d_amount) * flt(self.doc.payment_days)
/ cint(self.doc.total_days_in_month), 2)
elif not self.doc.payment_days:
d.d_modified_amount = 0
else:
d.d_modified_amount = d.d_amount
m+=flt(d.d_modified_amount)
#m+=flt(d.d_modified_amount)
self.doc.total_deduction= m+flt(r)
def validate(self):
super(DocType, self).validate()
self.validate_posting_time()
self.so_dn_required()
self.validate_proj_cust()
self.validate_with_previous_doc()
self.validate_uom_is_integer("stock_uom", "qty")
self.check_stop_sales_order("sales_order")
self.validate_customer_account()
self.validate_debit_acc()
self.validate_fixed_asset_account()
self.clear_unallocated_advances("Sales Invoice Advance", "advance_adjustment_details")
self.add_remarks()
if cint(self.doc.is_pos):
self.validate_pos()
self.validate_write_off_account()
if cint(self.doc.update_stock):
self.validate_item_code()
self.update_current_stock()
self.validate_delivery_note()
if not self.doc.is_opening:
self.doc.is_opening = 'No'
self.set_aging_date()
self.set_against_income_account()
self.validate_c_form()
self.validate_time_logs_are_submitted()
self.validate_recurring_invoice()
self.validate_multiple_billing("Delivery Note", "dn_detail", "export_amount",
"delivery_note_details")
def on_submit(self):
if cint(self.doc.is_pos) == 1:
if cint(self.doc.update_stock) == 1:
sl_obj = get_obj("Stock Ledger")
sl_obj.validate_serial_no_warehouse(self, 'entries')
sl_obj.validate_serial_no_warehouse(self, 'packing_details')
sl_obj.update_serial_record(self, 'entries', is_submit = 1, is_incoming = 0)
sl_obj.update_serial_record(self, 'packing_details', is_submit = 1, is_incoming = 0)
self.update_stock_ledger(update_stock=1)
else:
# Check for Approving Authority
if not self.doc.recurring_id:
get_obj('Authorization Control').validate_approving_authority(self.doc.doctype, self.doc.company, self.doc.grand_total, self)
self.check_prev_docstatus()
get_obj("Sales Common").update_prevdoc_detail(1,self)
# this sequence because outstanding may get -ve
self.make_gl_entries()
if not cint(self.doc.is_pos) == 1:
self.update_against_document_in_jv()
self.update_c_form()
self.convert_to_recurring()
def calc_next_day(self, next_year, next_month):
bill_cycle_day = cstr(self.doc.billing_cycle_date).split('-')[2]
if cint(next_month) == 2 and next_year%4==0 and (next_year%100!=0 or next_year%400==0) and cint(bill_cycle_day) > 28:
bill_cycle_day = '28'
elif cint(bill_cycle_day) == 31 and cint(next_month) in (4,6,9,11):
bill_cycle_day = '30'
return bill_cycle_day
def on_submit(self):
if cint(self.doc.update_stock) == 1:
self.update_stock_ledger(update_stock=1)
self.update_serial_nos()
else:
# Check for Approving Authority
if not self.doc.recurring_id:
get_obj('Authorization Control').validate_approving_authority(self.doc.doctype,
self.doc.company, self.doc.grand_total, self)
self.set_buying_amount()
self.check_prev_docstatus()
self.update_status_updater_args()
self.update_prevdoc_status()
# this sequence because outstanding may get -ve
self.make_gl_entries()
if not cint(self.doc.is_pos) == 1:
self.update_against_document_in_jv()
self.update_c_form()
self.update_time_log_batch(self.doc.name)
self.convert_to_recurring()
def account_expiry_reminder(self):
import webnotes.utils
from datetime import datetime
# Payment Reminder in case of not enough balance
cr_reqd = cint(self.doc.total_users)
days_left = cint(self.calc_days())
# check if account balance is sufficient
if cint(self.doc.credit_balance)<(cr_reqd):
# Difference between last payment date and current date
if self.doc.last_deduction_date: last_payment = date_diff(nowdate(),self.doc.last_deduction_date)
else: last_payment = -1
# 7 days extension
remaining_days = days_left - 24
if last_payment > 30 or last_payment == -1:
if remaining_days < 8 and remaining_days >= 1:
return "Your account will be de-activated in " + cstr(remaining_days) + " days. Please contact your System Manager to buy credits."
elif remaining_days==0:
return "Your account will be disabled from tomorrow. Please contact your System Manager to buy credits."
elif not has_common(['Administrator'],webnotes.user.get_roles()):
return "Stopped"
# check if user account is extended for seven days
if cint(self.doc.is_trial_account)==0:
if days_left < 10 and days_left >= 0:
return "You have only %s Credits in your account. Buy credits before %s." % (cint(self.doc.credit_balance),formatdate(self.next_bill_sdate))
def get_details_for_packing(self):
"""
Returns
* 'Delivery Note Items' query result as a list of dict
* Item Quantity dict of current packing slip doc
* No. of Cases of this packing slip
"""
item_codes = ", ".join([('"' + d.item_code + '"') for d in
self.doclist])
items = [d.item_code for d in self.doclist.get({"parentfield": "item_details"})]
if not item_codes: webnotes.msgprint("No Items to Pack",
raise_exception=1)
# gets item code, qty per item code, latest packed qty per item code and stock uom
res = webnotes.conn.sql("""select item_code, ifnull(sum(qty), 0) as qty,
(select sum(ifnull(psi.qty, 0) * (abs(ps.to_case_no - ps.from_case_no) + 1))
from `tabPacking Slip` ps, `tabPacking Slip Item` psi
where ps.name = psi.parent and ps.docstatus = 1
and ps.delivery_note = dni.parent and psi.item_code=dni.item_code)
as packed_qty,
stock_uom
from `tabDelivery Note Item` dni
where parent=%s and item_code in (%s)
group by item_code""" % ("%s", ", ".join(["%s"]*len(items))),
tuple([self.doc.delivery_note] + items), as_dict=1)
ps_item_qty = dict([[d.item_code, d.qty] for d in self.doclist])
no_of_cases = cint(self.doc.to_case_no) - cint(self.doc.from_case_no) + 1
return res, ps_item_qty, no_of_cases
def cal_tax(self, ocd, prd, rate, net_total, oc):
tax_amount = 0
if ocd[oc].charge_type == 'Actual':
value = flt(flt(rate) / flt(net_total))
return flt(flt(value) * flt(prd.amount))
elif ocd[oc].charge_type == 'On Net Total':
return flt(flt(rate) * flt(prd.amount) / 100)
elif ocd[oc].charge_type == 'On Previous Row Amount':
row_no = cstr(ocd[oc].row_id)
row = (row_no).split("+")
for r in range(0, len(row.length)):
id = cint(row[r])
tax_amount += flt((flt(rate) * flt(ocd[id-1].total_amount) / 100))
row_id = row_no.find("/")
if row_id != -1:
rate = ''
row = (row_no).split("/")
id1 = cint(row[0])
id2 = cint(row[1])
tax_amount = flt(flt(ocd[id1-1].total_amount) / flt(ocd[id2-1].total_amount))
return tax_amount
def test_5_make_autoname(self):
new_name = doc.make_autoname(self.test_doc.name,self.test_doc.parenttype)
last_name = testlib.test_conn.sql("select name from `tab%s` order by name desc limit 1"%testlib.test_doctype)
if not last_name:
last_name = '0'
webnotes.conn.commit()
assert (cint(new_name[get_num_start_pos(new_name):])) - cint(last_name[get_num_start_pos(last_name):])
def validate_value(self, fieldname, condition, val2, doc=None, raise_exception=None):
"""check that value of fieldname should be 'condition' val2
else throw exception"""
if not doc:
doc = self.doc
df = self.meta.get_field(fieldname, parent=doc.doctype)
val1 = doc.fields.get(fieldname)
if df.fieldtype in ("Currency", "Float"):
val1 = flt(val1, self.precision(df.fieldname, doc.parentfield or None))
val2 = flt(val2, self.precision(df.fieldname, doc.parentfield or None))
elif df.fieldtype in ("Int", "Check"):
val1 = cint(val1)
val2 = cint(val2)
if not webnotes.compare(val1, condition, val2):
msg = _("Error") + ": "
if doc.parentfield:
msg += _("Row") + (" # %d: " % doc.idx)
msg += _(self.meta.get_label(fieldname, parent=doc.doctype)) \
+ " " + error_condition_map.get(condition, "") + " " + cstr(val2)
# raise passed exception or True
msgprint(msg, raise_exception=raise_exception or True)
def set_pos_fields(self, for_validate=False):
"""Set retail related fields from pos settings"""
if cint(self.doc.is_pos) != 1:
return
from selling.utils import get_pos_settings, apply_pos_settings
pos = get_pos_settings(self.doc.company)
if pos:
if not for_validate and not self.doc.customer:
self.doc.customer = pos.customer
self.set_customer_defaults()
for fieldname in ('territory', 'naming_series', 'currency', 'charge', 'letter_head', 'tc_name',
'selling_price_list', 'company', 'select_print_heading', 'cash_bank_account'):
if (not for_validate) or (for_validate and not self.doc.fields.get(fieldname)):
self.doc.fields[fieldname] = pos.get(fieldname)
if not for_validate:
self.doc.update_stock = cint(pos.get("update_stock"))
# set pos values in items
for item in self.doclist.get({"parentfield": "entries"}):
if item.fields.get('item_code'):
for fieldname, val in apply_pos_settings(pos, item.fields).items():
if (not for_validate) or (for_validate and not item.fields.get(fieldname)):
item.fields[fieldname] = val
# fetch terms
if self.doc.tc_name and not self.doc.terms:
self.doc.terms = webnotes.conn.get_value("Terms and Conditions", self.doc.tc_name, "terms")
# fetch charges
if self.doc.charge and not len(self.doclist.get({"parentfield": "other_charges"})):
self.set_taxes("other_charges", "charge")
def validate(self):
super(DocType, self).validate()
self.so_dn_required()
self.validate_proj_cust()
sales_com_obj = get_obj('Sales Common')
sales_com_obj.check_stop_sales_order(self)
sales_com_obj.check_active_sales_items(self)
sales_com_obj.check_conversion_rate(self)
sales_com_obj.validate_max_discount(self, 'entries')
sales_com_obj.get_allocated_sum(self)
sales_com_obj.validate_fiscal_year(self.doc.fiscal_year,
self.doc.posting_date,'Posting Date')
self.validate_customer()
self.validate_customer_account()
self.validate_debit_acc()
self.validate_fixed_asset_account()
self.clear_unallocated_advances("Sales Invoice Advance", "advance_adjustment_details")
self.add_remarks()
if cint(self.doc.is_pos):
self.validate_pos()
self.validate_write_off_account()
if cint(self.doc.update_stock):
sl = get_obj('Stock Ledger')
sl.validate_serial_no(self, 'entries')
sl.validate_serial_no(self, 'packing_details')
self.validate_item_code()
self.update_current_stock()
self.validate_delivery_note()
if not self.doc.is_opening:
self.doc.is_opening = 'No'
self.set_aging_date()
self.set_against_income_account()
self.validate_c_form()
self.validate_recurring_invoice()
def update_parent_info(self):
idx_map = {}
is_local = cint(self.doc.fields.get("__islocal"))
if not webnotes.flags.in_import:
parentfields = [d.fieldname for d in self.meta.get({"doctype": "DocField", "fieldtype": "Table"})]
for i, d in enumerate(self.doclist[1:]):
if d.parentfield:
if not webnotes.flags.in_import:
if not d.parentfield in parentfields:
webnotes.msgprint("Bad parentfield %s" % d.parentfield,
raise_exception=True)
d.parenttype = self.doc.doctype
d.parent = self.doc.name
if not d.idx:
d.idx = idx_map.setdefault(d.parentfield, 0) + 1
else:
d.idx = cint(d.idx)
if is_local:
# if parent is new, all children should be new
d.fields["__islocal"] = 1
d.name = None
idx_map[d.parentfield] = d.idx
def __init__(self, login=None, password=None, server=None, port=None, use_ssl=None):
# get defaults from control panel
try:
es = webnotes.doc('Email Settings','Email Settings')
except webnotes.DoesNotExistError:
es = None
self._sess = None
if server:
self.server = server
self.port = port
self.use_ssl = cint(use_ssl)
self.login = login
self.password = password
elif es and es.outgoing_mail_server:
self.server = es.outgoing_mail_server
self.port = es.mail_port
self.use_ssl = cint(es.use_ssl)
self.login = es.mail_login
self.password = es.mail_password
self.always_use_login_id_as_sender = es.always_use_login_id_as_sender
else:
self.server = webnotes.conf.get("mail_server") or ""
self.port = webnotes.conf.get("mail_port") or None
self.use_ssl = cint(webnotes.conf.get("use_ssl") or 0)
self.login = webnotes.conf.get("mail_login") or ""
self.password = webnotes.conf.get("mail_password") or ""
def make_gl_entries(self):
from accounts.general_ledger import make_gl_entries, merge_similar_entries
gl_entries = []
self.make_customer_gl_entry(gl_entries)
self.make_tax_gl_entries(gl_entries)
self.make_item_gl_entries(gl_entries)
# merge gl entries before adding pos entries
gl_entries = merge_similar_entries(gl_entries)
self.make_pos_gl_entries(gl_entries)
update_outstanding = cint(self.doc.is_pos) and self.doc.write_off_account and 'No' or 'Yes'
if gl_entries:
make_gl_entries(gl_entries, cancel=(self.doc.docstatus == 2),
update_outstanding=update_outstanding, merge_entries=False)
if cint(webnotes.defaults.get_global_default("auto_accounting_for_stock")) \
and cint(self.doc.update_stock):
self.update_gl_entries_after()
def validate_inclusive_tax(self, tax):
def _on_previous_row_error(row_range):
msgprint((_("Row") + " # %(idx)s [%(doctype)s]: " +
_("to be included in Item's rate, it is required that: ") +
" [" + _("Row") + " # %(row_range)s] " + _("also be included in Item's rate")) % {
"idx": tax.idx,
"doctype": tax.doctype,
"inclusive_label": self.meta.get_label("included_in_print_rate",
parentfield=self.other_fname),
"charge_type_label": self.meta.get_label("charge_type",
parentfield=self.other_fname),
"charge_type": tax.charge_type,
"row_range": row_range
}, raise_exception=True)
if cint(tax.included_in_print_rate):
if tax.charge_type == "Actual":
# inclusive tax cannot be of type Actual
msgprint((_("Row")
+ " # %(idx)s [%(doctype)s]: %(charge_type_label)s = \"%(charge_type)s\" "
+ "cannot be included in Item's rate") % {
"idx": tax.idx,
"doctype": tax.doctype,
"charge_type_label": self.meta.get_label("charge_type",
parentfield=self.other_fname),
"charge_type": tax.charge_type,
}, raise_exception=True)
elif tax.charge_type == "On Previous Row Amount" and \
not cint(self.tax_doclist[tax.row_id - 1].included_in_print_rate):
# referred row should also be inclusive
_on_previous_row_error(tax.row_id)
elif tax.charge_type == "On Previous Row Total" and \
not all([cint(t.included_in_print_rate) for t in self.tax_doclist[:tax.row_id - 1]]):
# all rows about the reffered tax should be inclusive
_on_previous_row_error("1 - %d" % (tax.row_id,))
def get_current_tax_amount(self, item, tax, item_tax_map):
tax_rate = self._get_tax_rate(tax, item_tax_map)
current_tax_amount = 0.0
if tax.charge_type == "Actual":
# distribute the tax amount proportionally to each item row
actual = flt(tax.rate, self.precision("tax_amount", tax))
current_tax_amount = (self.doc.net_total
and ((item.amount / self.doc.net_total) * actual)
or 0)
elif tax.charge_type == "On Net Total":
current_tax_amount = (tax_rate / 100.0) * item.amount
elif tax.charge_type == "On Previous Row Amount":
current_tax_amount = (tax_rate / 100.0) * \
self.tax_doclist[cint(tax.row_id) - 1].tax_amount_for_current_item
elif tax.charge_type == "On Previous Row Total":
current_tax_amount = (tax_rate / 100.0) * \
self.tax_doclist[cint(tax.row_id) - 1].grand_total_for_current_item
current_tax_amount = flt(current_tax_amount, self.precision("tax_amount", tax))
# store tax breakup for each item
key = item.item_code or item.item_name
if tax.item_wise_tax_detail.get(key):
item_wise_tax_amount = tax.item_wise_tax_detail[key][1] + current_tax_amount
tax.item_wise_tax_detail[key] = [tax_rate, item_wise_tax_amount]
else:
tax.item_wise_tax_detail[key] = [tax_rate, current_tax_amount]
return current_tax_amount
def validate(self):
previous_auto_inventory_accounting = cint(webnotes.conn.get_value("Global Defaults", None,
"auto_inventory_accounting"))
if cint(self.doc.auto_inventory_accounting) != previous_auto_inventory_accounting:
from accounts.utils import create_stock_in_hand_jv
create_stock_in_hand_jv(reverse = \
cint(self.doc.auto_inventory_accounting) < previous_auto_inventory_accounting)
def __init__(self, login=None, password=None, server=None, port=None, use_ssl=None):
import webnotes.model.doc
from webnotes.utils import cint
# get defaults from control panel
es = webnotes.model.doc.Document('Email Settings','Email Settings')
self._sess = None
if server:
self.server = server
self.port = port
self.use_ssl = cint(use_ssl)
self.login = login
self.password = password
elif es.outgoing_mail_server:
self.server = es.outgoing_mail_server
self.port = es.mail_port
self.use_ssl = cint(es.use_ssl)
self.login = es.mail_login
self.password = es.mail_password
else:
self.server = getattr(conf, "mail_server", "")
self.port = getattr(conf, "mail_port", None)
self.use_ssl = cint(getattr(conf, "use_ssl", 0))
self.login = getattr(conf, "mail_login", "")
self.password = getattr(conf, "mail_password", "")
def validate(self):
self.so_dn_required()
# self.dn_required()
self.validate_proj_cust()
sales_com_obj = get_obj("Sales Common")
sales_com_obj.check_stop_sales_order(self)
sales_com_obj.check_active_sales_items(self)
sales_com_obj.check_conversion_rate(self)
sales_com_obj.validate_max_discount(self, "entries") # verify whether rate is not greater than tolerance
sales_com_obj.get_allocated_sum(self) # this is to verify that the allocated % of sales persons is 100%
sales_com_obj.validate_fiscal_year(self.doc.fiscal_year, self.doc.posting_date, "Posting Date")
self.validate_customer()
self.validate_debit_to_acc()
self.validate_debit_acc()
self.validate_fixed_asset_account()
self.add_remarks()
if cint(self.doc.is_pos):
self.validate_pos()
self.validate_write_off_account()
if cint(self.doc.update_stock):
get_obj("Stock Ledger").validate_serial_no(self, "entries")
self.validate_item_code()
self.update_current_stock()
self.set_in_words()
if not self.doc.is_opening:
self.doc.is_opening = "No"
self.set_aging_date()
self.clear_advances()
# Set against account
self.set_against_income_account()
self.validate_c_form()
def get_children(self, arg='', only_type='', in_roles=[]):
type_cond = only_type and (" and menu_item_type='%s'" % only_type) or ''
import webnotes
roles = webnotes.user.get_roles()
all_read = webnotes.user.can_get_report
cl = sql("select name, menu_item_label, menu_item_type, link_id, link_content, has_children, icon, `order`, criteria_name, doctype_fields, onload from `tabMenu Item` where ifnull(disabled,'No')!='Yes' and ifnull(parent_menu_item,'')='%s' %s order by `order` asc" % (arg, type_cond), as_dict=1)
ol = []
for c in cl:
c['has_children'] = cint(c['has_children'])
c['order'] = cint(c['order'])
for k in c.keys():
if c[k]==None: c[k] = ''
# check permission
if c['menu_item_type'] in ('DocType','Single','Report'):
if c['link_id'] in all_read:
ol.append(c)
elif c['menu_item_type']=='Page':
# page
if c['link_id'].startswith('_'):
ol.append(c)
elif has_common([r[0] for r in sql("select role from `tabPage Role` where parent=%s", c['link_id'])], roles):
ol.append(c)
elif cstr(c['menu_item_type'])=='':
# sections
if has_common([r[0] for r in sql("select role from `tabMenu Item Role` where parent=%s", c['name'])], roles):
ol.append(c)
else:
ol.append(c)
return ol
def get_leave_details(self, lwp=None):
if not self.doc.fiscal_year:
self.doc.fiscal_year = webnotes.get_default("fiscal_year")
if not self.doc.month:
self.doc.month = "%02d" % getdate(nowdate()).month
m = get_obj('Salary Manager').get_month_details(self.doc.fiscal_year, self.doc.month)
holidays = self.get_holidays_for_employee(m)
if not cint(webnotes.conn.get_value("HR Settings", "HR Settings",
"include_holidays_in_total_working_days")):
m["month_days"] -= len(holidays)
if m["month_days"] < 0:
msgprint(_("Bummer! There are more holidays than working days this month."),
raise_exception=True)
if not lwp:
lwp = self.calculate_lwp(holidays, m)
self.doc.total_days_in_month = m['month_days']
self.doc.leave_without_pay = lwp
payment_days = flt(self.get_payment_days(m)) - flt(lwp)
self.doc.payment_days = payment_days > 0 and payment_days or 0
ss="select DATEDIFF(NOW(),(select date_of_joining from tabEmployee where name='"+self.doc.employee+"'))/365 from tabEmployee where name='"+self.doc.employee+"' and status='Left' and DATEDIFF(CURDATE(), (select relieving_date from tabEmployee where name='"+self.doc.employee+"')) <=31 and DATEDIFF(NOW(),(select date_of_joining from tabEmployee where name='"+self.doc.employee+"'))/365 >5"
# webnotes.errprint(ss)
res=webnotes.conn.sql(ss)
# webnotes.errprint(res)
if res:
lst_sal_qry="select net_pay from `tabSalary Slip` where employee='"+self.doc.employee+"' order by creation desc limit 1"
# webnotes.errprint(lst_sal_qry)
lst_sal=webnotes.conn.sql(lst_sal_qry)
grp_amt=(cint(lst_sal[0][0])* cint(res[0][0]))/27
# webnotes.errprint(grp_amt)
self.doc.grauity_amount=grp_amt
def cal_tax(self, ocd, prd, rate, net_total, oc):
""" Calculates tax amount for one item"""
tax_amount = 0
if ocd[oc].charge_type == 'Actual':
tax_amount = flt(rate) * flt(prd.amount) / flt(net_total)
elif ocd[oc].charge_type == 'On Net Total':
tax_amount = flt(rate) * flt(prd.amount) / 100
elif ocd[oc].charge_type == 'On Previous Row Amount':
row_no = cstr(ocd[oc].row_id)
row = row_no.split("+")
for r in range(0, len(row)):
id = cint(row[r])
tax_amount += flt((flt(rate) * flt(ocd[id-1].total_amount) / 100))
row_id = row_no.find("/")
if row_id != -1:
rate = ''
row = (row_no).split("/")
id1 = cint(row[0])
id2 = cint(row[1])
tax_amount = flt(flt(ocd[id1-1].total_amount) / flt(ocd[id2-1].total_amount))
elif ocd[oc].charge_type == 'On Previous Row Total':
row = cint(ocd[oc].row_id)
if ocd[row-1].add_deduct_tax == 'Add':
tax_amount = flt(rate) * (flt(ocd[row-1].total_tax_amount)+flt(ocd[row-1].total_amount)) / 100
elif ocd[row-1].add_deduct_tax == 'Deduct':
tax_amount = flt(rate) * (flt(ocd[row-1].total_tax_amount)-flt(ocd[row-1].total_amount)) / 100
return tax_amount
def get_weekdates(self,lst):
from datetime import date, timedelta
d = dt = self.make_date(lst)
date_lst = [[1,cstr(d.strftime("%d/%m/%y"))]]
week=flag =1
j=1
last_day = sql("select last_day('%s')"%d)[0][0]
lst_m = cint(lst.split(',')[0])
for i in range(2,8):
f=0
if(dt < last_day):
#if(d.weekday()>4):
#d = d+timedelta(7-d.weekday())
#else:
d = d - timedelta(d.weekday()-1)
dlt = timedelta(days = (week-1)*7)
dt = d + dlt + timedelta(days=6)
if(cint(sql("select month('%s')"%dt)[0][0]) == lst_m and dt!=last_day):
for k in date_lst:
if(cstr(dt.strftime("%d/%m/%y")) == k[1]):
f = 1
if f == 0:
date_lst.append([i,cstr(dt.strftime("%d/%m/%y"))])
elif(dt==last_day and flag ==1):
date_lst.append([i,cstr(last_day.strftime("%d/%m/%y"))])
flag = 0
elif(flag == 1):
date_lst.append([i,cstr(last_day.strftime("%d/%m/%y"))])
week += 1
return date_lst and date_lst or ''
def make_item_gl_entries(self, gl_entries):
# income account gl entries
for item in self.doclist.get({"parentfield": "entries"}):
if flt(item.amount):
gl_entries.append(
self.get_gl_dict(
{
"account": item.income_account,
"against": self.doc.debit_to,
"credit": item.amount,
"remarks": self.doc.remarks,
"cost_center": item.cost_center,
}
)
)
# expense account gl entries
if (
cint(webnotes.defaults.get_global_default("auto_inventory_accounting"))
and cint(self.doc.is_pos)
and cint(self.doc.update_stock)
):
for item in self.doclist.get({"parentfield": "entries"}):
self.check_expense_account(item)
if item.buying_amount:
gl_entries += self.get_gl_entries_for_stock(
item.expense_account, -1 * item.buying_amount, cost_center=item.cost_center
)
def set_next_date(self):
""" Set next date on which auto invoice will be created"""
if not self.doc.repeat_on_day_of_month:
msgprint("""Please enter 'Repeat on Day of Month' field value.
The day of the month on which auto invoice
will be generated e.g. 05, 28 etc.""",
raise_exception=1)
next_date = get_next_date(self.doc.posting_date,
month_map[self.doc.recurring_type],
cint(self.doc.repeat_on_day_of_month))
webnotes.conn.set(self.doc, 'next_date', next_date)
def has_permission(doctype, ptype="read", refdoc=None):
"""check if user has permission"""
from webnotes.utils import cint
if session.user == "Administrator" or conn.get_value(
"DocType", doctype, "istable") == 1:
return True
meta = get_doctype(doctype)
# get user permissions
user_roles = get_roles()
perms = [
p for p in meta.get({"doctype": "DocPerm"})
if cint(p.get(ptype)) == 1 and cint(p.permlevel) == 0 and (
p.role == "All" or p.role in user_roles)
]
if refdoc:
return has_match(meta, perms, refdoc)
else:
return perms and True or False
def update_series_start(self):
if self.doc.prefix:
ser_det = sql("select name from `tabSeries` where name = %s",
self.doc.prefix)
if ser_det:
sql("update `tabSeries` set current = '%s' where name = '%s'" %
(self.doc.starts_from - 1, self.doc.prefix))
else:
sql("insert into tabSeries (name, current) values (%s,%s)",
(cstr(self.doc.prefix), cint(self.doc.starts_from) - 1))
msgprint("Series Updated Successfully")
else:
msgprint("Please select prefix first")
def check_eligible(self, person, person_allocated_amt):
if self.fiscal_year:
target_amt_percent = self.target_all_details(
person, (self.fiscal_year)[0][0],
self.months.get(cint(self.from_date(self.quater_month).month)))
if target_amt_percent:
for amt in target_amt_percent:
quater_target_amount = flt(amt[0]) * flt(amt[1]) / flt(100)
percent = flt(person_allocated_amt) / flt(
quater_target_amount) * 100
if percent >= 75:
webnotes.conn.sql(
"""update `tabSales Team` set eligible='True',fiscal_year='%s',quater='%s' where sales_person='%s'
and parent in (select name from `tabSales Order` where transaction_date between '%s' and '%s') and docstatus=1"""
%
((self.fiscal_year)[0][0],
self.months.get(
cint(self.from_date(
self.quater_month).month)), person,
self.from_date(
self.quater_month), self.to_date()))
webnotes.conn.sql("commit")
def validate_warehouse_account(self):
if not cint(webnotes.defaults.get_global_default("auto_accounting_for_stock")):
return
if self.doc.account_type == "Warehouse":
old_warehouse = cstr(webnotes.conn.get_value("Account", self.doc.name, "master_name"))
if old_warehouse != cstr(self.doc.master_name):
if old_warehouse:
self.validate_warehouse(old_warehouse)
if self.doc.master_name:
self.validate_warehouse(self.doc.master_name)
else:
webnotes.throw(_("Master Name is mandatory if account type is Warehouse"))
def check_level_zero_is_set(d):
if cint(d.permlevel) > 0 and d.role != 'All':
if not permissions.get({"role": d.role, "permlevel": 0}):
webnotes.msgprint(
get_txt(d) +
" Higher level permissions are meaningless if level 0 permission is not set.",
raise_exception=True)
if d.create or d.submit or d.cancel or d.amend or d.match:
webnotes.msgprint(
"Create, Submit, Cancel, Amend, Match has no meaning at level "
+ d.permlevel,
raise_exception=True)
def get_current_tax_fraction(self, tax, item_tax_map): """ Get tax fraction for calculating tax exclusive amount from tax inclusive amount """ current_tax_fraction = 0 if cint(tax.included_in_print_rate): tax_rate = self._get_tax_rate(tax, item_tax_map) if tax.charge_type == "On Net Total": current_tax_fraction = tax_rate / 100.0 elif tax.charge_type == "On Previous Row Amount": current_tax_fraction = (tax_rate / 100.0) * \ self.tax_doclist[cint(tax.row_id) - 1].tax_fraction_for_current_item elif tax.charge_type == "On Previous Row Total": current_tax_fraction = (tax_rate / 100.0) * \ self.tax_doclist[cint(tax.row_id) - 1].grand_total_fraction_for_current_item return current_tax_fraction
def on_submit(self):
if cint(self.doc.is_pos) == 1:
if cint(self.doc.update_stock) == 1:
sl_obj = get_obj("Stock Ledger")
sl_obj.validate_serial_no_warehouse(self, 'entries')
sl_obj.update_serial_record(self, 'entries', is_submit = 1, is_incoming = 0)
self.pos_update_stock()
else:
self.check_prev_docstatus()
get_obj("Sales Common").update_prevdoc_detail(1,self)
# Check for Approving Authority
if not self.doc.recurring_id:
get_obj('Authorization Control').validate_approving_authority(self.doc.doctype, self.doc.company, self.doc.grand_total, self)
# this sequence because outstanding may get -ve
self.make_gl_entries()
if not cint(self.doc.is_pos) == 1:
self.update_against_document_in_jv()
self.update_c_form()
def validate_expense_account(self):
if not cint(webnotes.defaults.get_global_default("auto_accounting_for_stock")):
return
if not self.doc.expense_account:
msgprint(_("Please enter Expense Account"), raise_exception=1)
elif not webnotes.conn.sql("""select * from `tabStock Ledger Entry`"""):
if webnotes.conn.get_value("Account", self.doc.expense_account,
"is_pl_account") == "Yes":
msgprint(_("""Expense Account can not be a PL Account, as this stock \
reconciliation is an opening entry. \
Please select 'Temporary Account (Liabilities)' or relevant account"""),
raise_exception=1)
def make_gl_entries(self):
if not cint(webnotes.defaults.get_global_default("auto_inventory_accounting")):
return
if not self.doc.expense_account:
msgprint(_("Please enter Expense Account"), raise_exception=1)
from accounts.general_ledger import make_gl_entries
gl_entries = self.get_gl_entries_for_stock(self.doc.expense_account,
self.doc.stock_value_difference)
if gl_entries:
make_gl_entries(gl_entries, cancel=self.doc.docstatus == 2)
def getseries(self, key, digits, doctype=''):
current = webnotes.conn.sql(
"select `current` from `tabSeries` where name='GID' for update")
if current and current[0][0] is not None:
current = current[0][0]
webnotes.conn.sql(
"update tabSeries set current = current+1 where name='GID'")
current = cint(current) + 1
else:
webnotes.conn.sql(
"insert into tabSeries (name, current) values ('GID', 1)")
current = 1
return ('%0' + str(digits) + 'd') % current
def set_total_in_words(self):
from webnotes.utils import money_in_words
company_currency = get_company_currency(self.doc.company)
disable_rounded_total = cint(webnotes.conn.get_value("Global Defaults", None,
"disable_rounded_total"))
if self.meta.get_field("in_words"):
self.doc.in_words = money_in_words(disable_rounded_total and
self.doc.grand_total or self.doc.rounded_total, company_currency)
if self.meta.get_field("in_words_export"):
self.doc.in_words_export = money_in_words(disable_rounded_total and
self.doc.grand_total_export or self.doc.rounded_total_export, self.doc.currency)
def getlist(doclist, field):
"""
Filter a list of records for a specific field from the full doclist
Example::
# find all phone call details
dl = getlist(self.doclist, 'contact_updates')
pl = []
for d in dl:
if d.type=='Phone':
pl.append(d)
"""
from webnotes.utils import cint
l = []
for d in doclist:
if d.parentfield == field:
l.append(d)
l.sort(lambda a, b: cint(a.idx) - cint(b.idx))
return l
def on_update(self):
sp = webnotes.conn.get_value('Sales Person',
{'employee': self.doc.employee}, 'name')
if sp:
sp_vp = webnotes.conn.sql(
"select name,variable_pay from `tabSales Person Variable Pay` where sales_person='%s' and fiscal_year='%s' and month='%s' and status='False'"
% (sp, self.doc.fiscal_year, self.doc.month),
as_list=1)
if sp_vp:
self.doc.gross_pay = cstr(
cint(self.doc.gross_pay) + cint(sp_vp[0][1]))
self.doc.net_pay = cstr(
cint(self.doc.net_pay) + cint(sp_vp[0][1]))
self.doc.variable_pay = cstr(sp_vp[0][1])
self.doc.save()
webnotes.conn.sql(
"update `tabSalary Slip Earning` set e_amount='%s',e_modified_amount='%s' where e_type='Variable Pay' and parent='%s'"
% (self.doc.variable_pay, self.doc.variable_pay,
self.doc.name))
webnotes.conn.sql(
"Update `tabSales Person Variable Pay` set status='True' where name ='%s'"
% (sp_vp[0][0]))
def precision(self, fieldname, parentfield=None):
parentfield = self._process(parentfield)
if not hasattr(self, "_precision"):
self._precision = webnotes._dict({
"default": cint(webnotes.conn.get_default("float_precision")) or 3,
"options": {}
})
if self._precision.setdefault(parentfield or "main", {}).get(fieldname) is None:
df = self.meta.get_field(fieldname, parentfield=parentfield)
if df.fieldtype == "Currency" and df.options and not self._precision.options.get(df.options):
self._precision.options[df.options] = get_field_precision(df, self.doc)
if df.fieldtype == "Currency":
self._precision[parentfield or "main"][fieldname] = cint(self._precision.options.get(df.options)) or \
self._precision.default
elif df.fieldtype == "Float":
self._precision[parentfield or "main"][fieldname] = self._precision.default
return self._precision[parentfield or "main"][fieldname]
def calculate_ded_total(self):
self.doc.total_deduction = 0
qry = webnotes.conn.sql(
" select name from `tabEmployee Loan` where employee_id=%s",
self.doc.employee,
as_list=1)
#webnotes.errprint(qry)
r = 0
if len(qry) != 0:
qr = webnotes.conn.sql(
"select date_of_installment from `tabLoan Installment Details` where parent=%s",
qry[0][0],
as_list=1)
for i in qr:
t = getdate(i[0]).month
if t == cint(self.doc.month):
q = webnotes.conn.sql(
"select amount_to_be_paid from `tabLoan Installment Details` where date_of_installment=%s and parent=%s",
(getdate(i[0]), qry[0][0]),
as_list=1)
w = webnotes.conn.sql(
"Update `tabLoan Installment Details` set status='Paid' where date_of_installment=%s",
getdate(i[0]))
#webnotes.errprint(q)
r = q[0][0]
self.doc.loan_amount = r
m = 0.0
for d in getlist(self.doclist, 'deduction_details'):
if cint(d.d_depends_on_lwp) == 1:
d.d_modified_amount = _round(
flt(d.d_amount) * flt(self.doc.payment_days) /
cint(self.doc.total_days_in_month), 2)
elif not self.doc.payment_days:
d.d_modified_amount = 0
else:
d.d_modified_amount = d.d_amount
m += flt(d.d_modified_amount)
#m+=flt(d.d_modified_amount)
self.doc.total_deduction = m + flt(r)
def get_leave_details(self, lwp=None):
if not self.doc.fiscal_year:
self.doc.fiscal_year = webnotes.get_default("fiscal_year")
if not self.doc.month:
self.doc.month = "%02d" % getdate(nowdate()).month
m = get_obj('Salary Manager').get_month_details(
self.doc.fiscal_year, self.doc.month)
holidays = self.get_holidays_for_employee(m)
if not cint(
webnotes.conn.get_value(
"HR Settings", "HR Settings",
"include_holidays_in_total_working_days")):
m["month_days"] -= len(holidays)
if m["month_days"] < 0:
msgprint(_(
"Bummer! There are more holidays than working days this month."
),
raise_exception=True)
if not lwp:
lwp = self.calculate_lwp(holidays, m)
self.doc.total_days_in_month = m['month_days']
self.doc.leave_without_pay = lwp
payment_days = flt(self.get_payment_days(m)) - flt(lwp)
self.doc.payment_days = payment_days > 0 and payment_days or 0
ss = "select DATEDIFF(NOW(),(select date_of_joining from tabEmployee where name='" + self.doc.employee + "'))/365 from tabEmployee where name='" + self.doc.employee + "' and status='Left' and DATEDIFF(CURDATE(), (select relieving_date from tabEmployee where name='" + self.doc.employee + "')) <=31 and DATEDIFF(NOW(),(select date_of_joining from tabEmployee where name='" + self.doc.employee + "'))/365 >5"
# webnotes.errprint(ss)
res = webnotes.conn.sql(ss)
# webnotes.errprint(res)
if res:
lst_sal_qry = "select net_pay from `tabSalary Slip` where employee='" + self.doc.employee + "' order by creation desc limit 1"
# webnotes.errprint(lst_sal_qry)
lst_sal = webnotes.conn.sql(lst_sal_qry)
grp_amt = (cint(lst_sal[0][0]) * cint(res[0][0])) / 27
# webnotes.errprint(grp_amt)
self.doc.grauity_amount = grp_amt
def make_gl_entries(self, update_gl_entries_after=True):
if self.doc.docstatus == 2:
delete_gl_entries(voucher_type=self.doc.doctype, voucher_no=self.doc.name)
if cint(webnotes.defaults.get_global_default("auto_accounting_for_stock")):
warehouse_account = self.get_warehouse_account()
if self.doc.docstatus==1:
gl_entries = self.get_gl_entries(warehouse_account)
make_gl_entries(gl_entries)
if update_gl_entries_after:
self.update_gl_entries_after(warehouse_account)
def autoname(self):
self.doc.name = self.doc.criteria_name.lower().replace('(','').replace(')', '')\
.replace('.','').replace(',','').replace('"', '').replace("'",'').replace(' ', '_')\
.replace('/', '-')
# for duplicates
if webnotes.conn.sql(
"select name from `tabSearch Criteria` where name = %s",
self.doc.name):
m = webnotes.conn.sql(
"select name from `tabSearch Criteria` where name like '%s%%' order by name desc limit 1"
% self.doc.name)[0][0]
self.doc.name = self.doc.name + str(cint(m[-1]) + 1)
def set_remember_me(self):
from webnotes.utils import cint
if not cint(webnotes.form_dict.get('remember_me')): return
remember_days = webnotes.conn.get_value('Control Panel', None,
'remember_for_days') or 7
import datetime
expires = datetime.datetime.now() + \
datetime.timedelta(days=remember_days)
webnotes._response.set_cookie["remember_me"] = 1
def get_details_for_packing(self):
"""
Returns
* 'Delivery Note Items' query result as a list of dict
* Item Quantity dict of current packing slip doc
* No. of Cases of this packing slip
"""
item_codes = ", ".join([('"' + d.item_code + '"')
for d in self.doclist])
items = [
d.item_code
for d in self.doclist.get({"parentfield": "item_details"})
]
if not item_codes:
webnotes.msgprint("No Items to Pack", raise_exception=1)
# gets item code, qty per item code, latest packed qty per item code and stock uom
res = webnotes.conn.sql(
"""select item_code, ifnull(sum(qty), 0) as qty,
(select sum(ifnull(psi.qty, 0) * (abs(ps.to_case_no - ps.from_case_no) + 1))
from `tabPacking Slip` ps, `tabPacking Slip Item` psi
where ps.name = psi.parent and ps.docstatus = 1
and ps.delivery_note = dni.parent and psi.item_code=dni.item_code)
as packed_qty,
stock_uom
from `tabDelivery Note Item` dni
where parent=%s and item_code in (%s)
group by item_code""" % ("%s", ", ".join(["%s"] * len(items))),
tuple([self.doc.delivery_note] + items),
as_dict=1)
ps_item_qty = dict([[d.item_code, d.qty] for d in self.doclist])
no_of_cases = cint(self.doc.to_case_no) - cint(
self.doc.from_case_no) + 1
return res, ps_item_qty, no_of_cases
def get_item_details(args):
"""
args = {
"item_code": "",
"warehouse": None,
"customer": "",
"conversion_rate": 1.0,
"price_list_name": None,
"price_list_currency": None,
"plc_conversion_rate": 1.0
}
"""
if isinstance(args, basestring):
args = json.loads(args)
args = webnotes._dict(args)
if args.barcode:
args.item_code = _get_item_code(args.barcode)
item_bean = webnotes.bean("Item", args.item_code)
_validate_item_details(args, item_bean.doc)
meta = webnotes.get_doctype(args.doctype)
# hack! for Sales Order Item
warehouse_fieldname = "warehouse"
if meta.get_field("reserved_warehouse", parentfield=args.parentfield):
warehouse_fieldname = "reserved_warehouse"
out = _get_basic_details(args, item_bean, warehouse_fieldname)
if meta.get_field("currency"):
out.base_ref_rate = out.basic_rate = out.ref_rate = out.export_rate = 0.0
if args.price_list_name and args.price_list_currency:
out.update(_get_price_list_rate(args, item_bean, meta))
out.update(_get_item_discount(out.item_group, args.customer))
if out.get(warehouse_fieldname):
out.update(
get_available_qty(args.item_code, out.get(warehouse_fieldname)))
out.customer_item_code = _get_customer_item_code(args, item_bean)
if cint(args.is_pos):
pos_settings = get_pos_settings(args.company)
out.update(apply_pos_settings(pos_settings, out))
return out
def validate(self):
# webnotes.errprint("TEST")
self.in_insert = self.doc.fields.get("__islocal")
if self.doc.name not in ('Guest', 'Administrator',
'SuAdmin') and self.doc.email:
self.validate_email_type(self.doc.email)
self.validate_max_users()
self.add_system_manager_role()
self.check_enable_disable()
if self.in_insert:
if self.doc.name not in ("Guest", "Administrator", "SuAdmin") and (
self.doc.email
or self.doc.number) and cint(self.doc.mute_email) != 1:
self.send_welcome_mail()
webnotes.msgprint(_("Welcome Message Sent"))
if cint(self.doc.mute_email) == 1 and self.doc.name not in (
"Guest", "Administrator", "SuAdmin"):
webnotes.conn.sql(
"insert into __Auth values ('%s', password('%s'))" %
(self.doc.name, 'password'))
webnotes.conn.sql("commit")
else:
if cint(self.doc.mute_email) != 1:
self.email_new_password()
if cint(self.doc.mute_email) == 1 and self.doc.name not in (
"Guest", "Administrator",
"SuAdmin") and self.doc.new_password:
webnotes.conn.sql(
"""update __Auth set password=password('%s') where user='******'"""
% (self.doc.new_password, self.doc.name),
debug=1)
webnotes.conn.sql("commit")
if cint(self.doc.mute_email) == 1 and self.doc.name in (
"Guest", "Administrator",
"SuAdmin") and self.doc.new_password:
from webnotes.auth import _update_password
_update_password(self.doc.name, self.doc.new_password)
self.doc.new_password = ""
def validate(self):
super(DocType, self).validate()
self.fetch_missing_values()
self.validate_posting_time()
self.so_dn_required()
self.validate_proj_cust()
sales_com_obj = get_obj('Sales Common')
sales_com_obj.check_stop_sales_order(self)
sales_com_obj.check_active_sales_items(self)
sales_com_obj.check_conversion_rate(self)
sales_com_obj.validate_max_discount(self, 'entries')
sales_com_obj.get_allocated_sum(self)
sales_com_obj.validate_fiscal_year(self.doc.fiscal_year,
self.doc.posting_date,'Posting Date')
self.validate_customer()
self.validate_customer_account()
self.validate_debit_acc()
self.validate_fixed_asset_account()
self.clear_unallocated_advances("Sales Invoice Advance", "advance_adjustment_details")
self.add_remarks()
if cint(self.doc.is_pos):
self.validate_pos()
self.validate_write_off_account()
if cint(self.doc.update_stock):
sl = get_obj('Stock Ledger')
sl.validate_serial_no(self, 'entries')
sl.validate_serial_no(self, 'packing_details')
self.validate_item_code()
self.update_current_stock()
self.validate_delivery_note()
if not self.doc.is_opening:
self.doc.is_opening = 'No'
self.set_aging_date()
self.set_against_income_account()
self.validate_c_form()
self.validate_rate_with_refdoc()
self.validate_time_logs_are_submitted()
self.validate_recurring_invoice()
def on_submit(self):
if cint(self.doc.update_stock) == 1:
sl_obj = get_obj("Stock Ledger")
sl_obj.validate_serial_no_warehouse(self, 'entries')
sl_obj.validate_serial_no_warehouse(self, 'packing_details')
sl_obj.update_serial_record(self,
'entries',
is_submit=1,
is_incoming=0)
sl_obj.update_serial_record(self,
'packing_details',
is_submit=1,
is_incoming=0)
self.update_stock_ledger(update_stock=1)
else:
# Check for Approving Authority
if not self.doc.recurring_id:
get_obj('Authorization Control').validate_approving_authority(
self.doc.doctype, self.doc.company, self.doc.grand_total,
self)
self.set_buying_amount()
self.check_prev_docstatus()
self.update_status_updater_args()
self.update_prevdoc_status()
# this sequence because outstanding may get -ve
self.make_gl_entries()
if not cint(self.doc.is_pos) == 1:
self.update_against_document_in_jv()
self.update_c_form()
self.update_time_log_batch(self.doc.name)
self.convert_to_recurring()
def make_gl_entries(self, cancel=False):
if not cint(webnotes.defaults.get_global_default("auto_inventory_accounting")):
return
from accounts.general_ledger import make_gl_entries
against_stock_account = self.get_company_default("stock_adjustment_account")
gl_entries = self.get_gl_entries_for_stock(against_stock_account, self.doc.purchase_rate)
for entry in gl_entries:
entry["posting_date"] = self.doc.purchase_date or (self.doc.creation and
self.doc.creation.split(' ')[0]) or nowdate()
if gl_entries:
make_gl_entries(gl_entries, cancel)
def get_file_timestamp(fn):
"""
Returns timestamp of the given file
"""
import os
from webnotes.utils import cint
try:
return str(cint(os.stat(fn).st_mtime))
except OSError, e:
if e.args[0] != 2:
raise
else:
return None
def validate_outgoing(self):
"""Checks incoming email settings"""
self.doc.encode()
if self.doc.outgoing_mail_server:
from webnotes.utils import cint
from webnotes.utils.email_lib.smtp import SMTPServer
smtpserver = SMTPServer(login=self.doc.mail_login,
password=self.doc.mail_password,
server=self.doc.outgoing_mail_server,
port=cint(self.doc.mail_port),
use_ssl=self.doc.use_ssl)
# exceptions are handled in session connect
sess = smtpserver.sess
def validate_on_previous_row(self, tax):
"""
validate if a valid row id is mentioned in case of
On Previous Row Amount and On Previous Row Total
"""
if tax.charge_type in ["On Previous Row Amount", "On Previous Row Total"] and \
(not tax.row_id or cint(tax.row_id) >= tax.idx):
msgprint((_("Row") + " # %(idx)s [%(taxes_doctype)s]: " + \
_("Please specify a valid") + " %(row_id_label)s") % {
"idx": tax.idx,
"taxes_doctype": tax.doctype,
"row_id_label": self.meta.get_label("row_id",
parentfield=self.other_fname)
}, raise_exception=True)
def validate_pop(self, pop_meta):
# throttle based on email size
if not self.max_email_size:
return
m, size = pop_meta.split()
size = cint(size)
if size < self.max_email_size:
self.total_size += size
if self.total_size > self.max_total_size:
raise TotalSizeExceededError
else:
raise EmailSizeExceededError
