def get_attached_images(doctype, names):
'''get list of image urls attached in form
returns {name: ['image.jpg', 'image.png']}'''
if isinstance(names, string_types):
names = json.loads(names)
img_urls = dataent.db.get_list(
'File',
filters={
'attached_to_doctype': doctype,
'attached_to_name': ('in', names),
'is_folder': 0
},
fields=['file_url', 'attached_to_name as docname'])
out = dataent._dict()
for i in img_urls:
out[i.docname] = out.get(i.docname, [])
out[i.docname].append(i.file_url)
return out
class JobOpening(WebsiteGenerator):
website = dataent._dict(
template = "templates/generators/job_opening.html",
condition_field = "publish",
page_title_field = "job_title",
)
def validate(self):
if not self.route:
self.route = dataent.scrub(self.job_title).replace('_', '-')
self.validate_current_vacancies()
def validate_current_vacancies(self):
if not self.staffing_plan:
staffing_plan = get_active_staffing_plan_details(self.company,
self.designation)
if staffing_plan:
self.staffing_plan = staffing_plan[0].name
self.planned_vacancies = staffing_plan[0].vacancies
elif not self.planned_vacancies:
planned_vacancies = dataent.db.sql("""
select vacancies from `tabStaffing Plan Detail`
where parent=%s and designation=%s""", (self.staffing_plan, self.designation))
self.planned_vacancies = planned_vacancies[0][0] if planned_vacancies else None
if self.staffing_plan and self.planned_vacancies:
staffing_plan_company = dataent.db.get_value("Staffing Plan", self.staffing_plan, "company")
lft, rgt = dataent.get_cached_value('Company', staffing_plan_company, ["lft", "rgt"])
designation_counts = get_designation_counts(self.designation, self.company)
current_count = designation_counts['employee_count'] + designation_counts['job_openings']
if self.planned_vacancies <= current_count:
dataent.throw(_("Job Openings for designation {0} already open \
or hiring completed as per Staffing Plan {1}"
.format(self.designation, self.staffing_plan)))
def get_context(self, context):
context.parents = [{'route': 'jobs', 'title': _('All Jobs') }]
def create_production_plan(**args):
args = dataent._dict(args)
pln = dataent.get_doc({
'doctype':
'Production Plan',
'company':
args.company or '_Test Company',
'posting_date':
nowdate(),
'include_non_stock_items':
args.include_non_stock_items or 1,
'include_subcontracted_items':
args.include_subcontracted_items or 1,
'ignore_existing_ordered_qty':
args.ignore_existing_ordered_qty or 1,
'po_items': [{
'use_multi_level_bom':
args.use_multi_level_bom or 1,
'item_code':
args.item_code,
'bom_no':
dataent.db.get_value('Item', args.item_code, 'default_bom'),
'planned_qty':
args.planned_qty or 1,
'planned_start_date':
args.planned_start_date or now_datetime()
}]
})
mr_items = get_items_for_material_requests(pln.as_dict())
for d in mr_items:
pln.append('mr_items', d)
if not args.do_not_save:
pln.insert()
if not args.do_not_submit:
pln.submit()
return pln
def openid_profile(*args, **kwargs):
picture = None
first_name, last_name, avatar, name = dataent.db.get_value("User", dataent.session.user, ["first_name", "last_name", "user_image", "name"])
dataent_userid = dataent.db.get_value("User Social Login", {"parent":dataent.session.user, "provider": "dataent"}, "userid")
request_url = urlparse(dataent.request.url)
if avatar:
if validate_url(avatar):
picture = avatar
else:
picture = request_url.scheme + "://" + request_url.netloc + avatar
user_profile = dataent._dict({
"sub": dataent_userid,
"name": " ".join(filter(None, [first_name, last_name])),
"given_name": first_name,
"family_name": last_name,
"email": name,
"picture": picture
})
dataent.local.response = user_profile
def fetch_as_dict(self, formatted=0, as_utf8=0):
"""Internal. Converts results to dict."""
result = self._cursor.fetchall()
ret = []
needs_formatting = self.needs_formatting(result, formatted)
if result:
keys = [column[0] for column in self._cursor.description]
for r in result:
values = []
for i in range(len(r)):
if needs_formatting:
val = self.convert_to_simple_type(r[i], formatted)
else:
val = r[i]
if as_utf8 and type(val) is text_type:
val = val.encode('utf-8')
values.append(val)
ret.append(dataent._dict(zip(keys, values)))
return ret
def upload_from_folder(path, is_private, dropbox_folder, dropbox_client, did_not_upload, error_log):
if not os.path.exists(path):
return
if is_fresh_upload():
response = get_uploaded_files_meta(dropbox_folder, dropbox_client)
else:
response = dataent._dict({"entries": []})
path = text_type(path)
for f in dataent.get_all("File", filters={"is_folder": 0, "is_private": is_private,
"uploaded_to_dropbox": 0}, fields=['file_url', 'name', 'file_name']):
if is_private:
filename = f.file_url.replace('/private/files/', '')
else:
if not f.file_url:
f.file_url = '/files/' + f.file_name;
filename = f.file_url.replace('/files/', '')
filepath = os.path.join(path, filename)
if filename in ignore_list:
continue
found = False
for file_metadata in response.entries:
if (os.path.basename(filepath) == file_metadata.name
and os.stat(encode(filepath)).st_size == int(file_metadata.size)):
found = True
update_file_dropbox_status(f.name)
break
if not found:
try:
upload_file_to_dropbox(filepath, dropbox_folder, dropbox_client)
update_file_dropbox_status(f.name)
except Exception:
did_not_upload.append(filepath)
error_log.append(dataent.get_traceback())
def get_child_exploded_items(self, bom_no, stock_qty):
""" Add all items from Flat BOM of child BOM"""
# Did not use qty_consumed_per_unit in the query, as it leads to rounding loss
child_fb_items = dataent.db.sql("""select bom_item.item_code, bom_item.item_name,
bom_item.description, bom_item.source_warehouse, bom_item.operation,
bom_item.stock_uom, bom_item.stock_qty, bom_item.rate, bom_item.include_item_in_manufacturing,
bom_item.stock_qty / ifnull(bom.quantity, 1) as qty_consumed_per_unit
from `tabBOM Explosion Item` bom_item, tabBOM bom
where bom_item.parent = bom.name and bom.name = %s and bom.docstatus = 1""", bom_no, as_dict = 1)
for d in child_fb_items:
self.add_to_cur_exploded_items(dataent._dict({
'item_code' : d['item_code'],
'item_name' : d['item_name'],
'source_warehouse' : d['source_warehouse'],
'operation' : d['operation'],
'description' : d['description'],
'stock_uom' : d['stock_uom'],
'stock_qty' : d['qty_consumed_per_unit'] * stock_qty,
'rate' : flt(d['rate']),
'include_item_in_manufacturing': d.get('include_item_in_manufacturing', 0)
}))
def get_ref_item_dict(valid_items, ref_item_row):
from epaas.stock.doctype.serial_no.serial_no import get_serial_nos
valid_items.setdefault(
ref_item_row.item_code,
dataent._dict({
"qty":
0,
"rate":
0,
"stock_qty":
0,
"rejected_qty":
0,
"received_qty":
0,
"serial_no": [],
"conversion_factor":
ref_item_row.get("conversion_factor", 1),
"batch_no": []
}))
item_dict = valid_items[ref_item_row.item_code]
item_dict["qty"] += ref_item_row.qty
item_dict["stock_qty"] += ref_item_row.get('stock_qty', 0)
if ref_item_row.get("rate", 0) > item_dict["rate"]:
item_dict["rate"] = ref_item_row.get("rate", 0)
if ref_item_row.parenttype in ['Purchase Invoice', 'Purchase Receipt']:
item_dict["received_qty"] += ref_item_row.received_qty
item_dict["rejected_qty"] += ref_item_row.rejected_qty
if ref_item_row.get("serial_no"):
item_dict["serial_no"] += get_serial_nos(ref_item_row.serial_no)
if ref_item_row.get("batch_no"):
item_dict["batch_no"].append(ref_item_row.batch_no)
return valid_items
def get_report_content(self):
'''Returns file in for the report in given format'''
report = dataent.get_doc('Report', self.report)
if self.report_type == 'Report Builder' and self.data_modified_till:
self.filters = json.loads(self.filters) if self.filters else {}
self.filters['modified'] = (
'>', now_datetime() - timedelta(hours=self.data_modified_till))
columns, data = report.get_data(limit=self.no_of_rows or 100,
user=self.user,
filters=self.filters,
as_dict=True)
# add serial numbers
columns.insert(0, dataent._dict(fieldname='idx',
label='',
width='30px'))
for i in range(len(data)):
data[i]['idx'] = i + 1
if len(data) == 0 and self.send_if_data:
return None
if self.format == 'HTML':
return self.get_html_table(columns, data)
elif self.format == 'XLSX':
spreadsheet_data = self.get_spreadsheet_data(columns, data)
xlsx_file = make_xlsx(spreadsheet_data, "Auto Email Report")
return xlsx_file.getvalue()
elif self.format == 'CSV':
spreadsheet_data = self.get_spreadsheet_data(columns, data)
return to_csv(spreadsheet_data)
else:
dataent.throw(_('Invalid Output Format'))
def get_achieved_details(filters, sales_person, all_sales_persons, target_item_group, item_groups):
start_date, end_date = get_fiscal_year(fiscal_year = filters["fiscal_year"])[1:]
item_details = dataent.db.sql("""
SELECT st.sales_person, MONTHNAME(so.transaction_date) as month_name,
CASE
WHEN so.status = "Closed" THEN sum(soi.delivered_qty * soi.conversion_factor * (st.allocated_percentage/100))
ELSE sum(soi.stock_qty * (st.allocated_percentage/100))
END as qty,
CASE
WHEN so.status = "Closed" THEN sum(soi.delivered_qty * soi.conversion_factor * soi.base_net_rate * (st.allocated_percentage/100))
ELSE sum(soi.base_net_amount * (st.allocated_percentage/100))
END as amount
from
`tabSales Order Item` soi, `tabSales Order` so, `tabSales Team` st
where
soi.parent=so.name and so.docstatus=1 and st.parent=so.name
and so.transaction_date>=%s and so.transaction_date<=%s
and exists(SELECT name from `tabSales Person` where lft >= %s and rgt <= %s and name=st.sales_person)
and exists(SELECT name from `tabItem Group` where lft >= %s and rgt <= %s and name=soi.item_group)
group by
sales_person, month_name
""",
(start_date, end_date, all_sales_persons[sales_person].lft, all_sales_persons[sales_person].rgt,
item_groups[target_item_group].lft, item_groups[target_item_group].rgt), as_dict=1)
actual_details = {}
for d in item_details:
actual_details.setdefault(d.month_name, dataent._dict({
"quantity" : 0,
"amount" : 0
}))
value_dict = actual_details[d.month_name]
value_dict.quantity += flt(d.qty)
value_dict.amount += flt(d.amount)
return actual_details
def reconcile(self, args):
for e in self.get('payments'):
e.invoice_type = None
if e.invoice_number and " | " in e.invoice_number:
e.invoice_type, e.invoice_number = e.invoice_number.split(
" | ")
self.get_invoice_entries()
self.validate_invoice()
dr_or_cr = ("credit_in_account_currency"
if epaas.get_party_account_type(self.party_type)
== 'Receivable' else "debit_in_account_currency")
lst = []
for e in self.get('payments'):
if e.invoice_number and e.allocated_amount:
lst.append(
dataent._dict({
'voucher_type': e.reference_type,
'voucher_no': e.reference_name,
'voucher_detail_no': e.reference_row,
'against_voucher_type': e.invoice_type,
'against_voucher': e.invoice_number,
'account': self.receivable_payable_account,
'party_type': self.party_type,
'party': self.party,
'is_advance': e.is_advance,
'dr_or_cr': dr_or_cr,
'unadjusted_amount': flt(e.amount),
'allocated_amount': flt(e.allocated_amount)
}))
if lst:
from epaas.accounts.utils import reconcile_against_document
reconcile_against_document(lst)
msgprint(_("Successfully Reconciled"))
self.get_unreconciled_entries()
def boot_session(bootinfo):
"""boot session - send website info if guest"""
bootinfo.custom_css = dataent.db.get_value('Style Settings', None,
'custom_css') or ''
bootinfo.website_settings = dataent.get_doc('Website Settings')
if dataent.session['user'] != 'Guest':
update_page_info(bootinfo)
load_country_and_currency(bootinfo)
bootinfo.sysdefaults.territory = dataent.db.get_single_value(
'Selling Settings', 'territory')
bootinfo.sysdefaults.customer_group = dataent.db.get_single_value(
'Selling Settings', 'customer_group')
bootinfo.sysdefaults.allow_stale = cint(
dataent.db.get_single_value('Accounts Settings', 'allow_stale'))
bootinfo.sysdefaults.quotation_valid_till = cint(
dataent.db.get_single_value('Selling Settings',
'default_valid_till'))
# if no company, show a dialog box to create a new company
bootinfo.customer_count = dataent.db.sql(
"""select count(*) from tabCustomer""")[0][0]
if not bootinfo.customer_count:
bootinfo.setup_complete = dataent.db.sql("""select name from
tabCompany limit 1""") and 'Yes' or 'No'
bootinfo.docs += dataent.db.sql(
"""select name, default_currency, cost_center, default_terms,
default_letter_head, default_bank_account, enable_perpetual_inventory, country from `tabCompany`""",
as_dict=1,
update={"doctype": ":Company"})
party_account_types = dataent.db.sql(
""" select name, ifnull(account_type, '') from `tabParty Type`""")
bootinfo.party_account_types = dataent._dict(party_account_types)
def get_columns(group_wise_columns, filters):
columns = []
column_map = dataent._dict({
"parent": _("Sales Invoice") + ":Link/Sales Invoice:120",
"posting_date": _("Posting Date") + ":Date",
"posting_time": _("Posting Time"),
"item_code": _("Item Code") + ":Link/Item",
"item_name": _("Item Name"),
"item_group": _("Item Group") + ":Link/Item Group",
"brand": _("Brand"),
"description": _("Description"),
"warehouse": _("Warehouse") + ":Link/Warehouse",
"qty": _("Qty") + ":Float",
"base_rate": _("Avg. Selling Rate") + ":Currency/currency",
"buying_rate": _("Valuation Rate") + ":Currency/currency",
"base_amount": _("Selling Amount") + ":Currency/currency",
"buying_amount": _("Buying Amount") + ":Currency/currency",
"gross_profit": _("Gross Profit") + ":Currency/currency",
"gross_profit_percent": _("Gross Profit %") + ":Percent",
"project": _("Project") + ":Link/Project",
"sales_person": _("Sales person"),
"allocated_amount": _("Allocated Amount") + ":Currency/currency",
"customer": _("Customer") + ":Link/Customer",
"customer_group": _("Customer Group") + ":Link/Customer Group",
"territory": _("Territory") + ":Link/Territory"
})
for col in group_wise_columns.get(scrub(filters.group_by)):
columns.append(column_map.get(col))
columns.append({
"fieldname": "currency",
"label" : _("Currency"),
"fieldtype": "Link",
"options": "Currency"
})
return columns
def get_invoice_tax_map(invoice_list, invoice_income_map, income_accounts):
tax_details = dataent.db.sql("""select parent, account_head,
sum(base_tax_amount_after_discount_amount) as tax_amount
from `tabSales Taxes and Charges` where parent in (%s) group by parent, account_head"""
% ', '.join(['%s'] * len(invoice_list)),
tuple([inv.name for inv in invoice_list]),
as_dict=1)
invoice_tax_map = {}
for d in tax_details:
if d.account_head in income_accounts:
if d.account_head in invoice_income_map[d.parent]:
invoice_income_map[d.parent][d.account_head] += flt(
d.tax_amount)
else:
invoice_income_map[d.parent][d.account_head] = flt(
d.tax_amount)
else:
invoice_tax_map.setdefault(d.parent, dataent._dict()).setdefault(
d.account_head, [])
invoice_tax_map[d.parent][d.account_head] = flt(d.tax_amount)
return invoice_income_map, invoice_tax_map
def get_page_info(self):
route = dataent._dict()
route.update({
"doc":
self,
"page_or_generator":
"Generator",
"ref_doctype":
self.doctype,
"idx":
self.idx,
"docname":
self.name,
"controller":
get_module_name(self.doctype, self.meta.module),
})
route.update(self.get_website_properties())
if not route.page_title:
route.page_title = self.get(self.get_title_field())
return route
def get_gst_accounts(company, account_wise=False):
gst_accounts = dataent._dict()
gst_settings_accounts = dataent.get_all("GST Account",
filters={
"parent": "GST Settings",
"company": company
},
fields=[
"cgst_account", "sgst_account",
"igst_account", "cess_account"
])
if not gst_settings_accounts:
dataent.throw(_("Please set GST Accounts in GST Settings"))
for d in gst_settings_accounts:
for acc, val in d.items():
if not account_wise:
gst_accounts.setdefault(acc, []).append(val)
elif val:
gst_accounts[val] = acc
return gst_accounts
def create_stock_reconciliation(**args):
args = dataent._dict(args)
sr = dataent.new_doc("Stock Reconciliation")
sr.posting_date = args.posting_date or nowdate()
sr.posting_time = args.posting_time or nowtime()
sr.set_posting_time = 1
sr.company = args.company or "_Test Company"
sr.expense_account = args.expense_account or \
("Stock Adjustment - _TC" if dataent.get_all("Stock Ledger Entry") else "Temporary Opening - _TC")
sr.cost_center = args.cost_center or "_Test Cost Center - _TC"
sr.append(
"items", {
"item_code": args.item_code or "_Test Item",
"warehouse": args.warehouse or "_Test Warehouse - _TC",
"qty": args.qty,
"valuation_rate": args.rate
})
try:
sr.submit()
except EmptyStockReconciliationItemsError:
pass
return sr
def get_lead_details(lead, posting_date=None, company=None):
if not lead: return {}
from epaas.accounts.party import set_address_details
out = dataent._dict()
lead_doc = dataent.get_doc("Lead", lead)
lead = lead_doc
out.update({
"territory":
lead.territory,
"customer_name":
lead.company_name or lead.lead_name,
"contact_display":
" ".join(filter(None, [lead.salutation, lead.lead_name])),
"contact_email":
lead.email_id,
"contact_mobile":
lead.mobile_no,
"contact_phone":
lead.phone,
})
set_address_details(out, lead, "Lead")
taxes_and_charges = set_taxes(
None,
'Lead',
posting_date,
company,
billing_address=out.get('customer_address'),
shipping_address=out.get('shipping_address_name'))
if taxes_and_charges:
out['taxes_and_charges'] = taxes_and_charges
return out
def validate(self):
self.set_lead_name()
self._prev = dataent._dict({
"contact_date": dataent.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"ends_on": dataent.db.get_value("Lead", self.name, "ends_on") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": dataent.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
self.check_email_id_is_unique()
if self.email_id:
if not self.flags.ignore_email_validation:
validate_email_add(self.email_id, True)
if self.email_id == self.lead_owner:
dataent.throw(_("Lead Owner cannot be same as the Lead"))
if self.email_id == self.contact_by:
dataent.throw(
_("Next Contact By cannot be same as the Lead Email Address"
))
if self.is_new() or not self.image:
self.image = has_gravatar(self.email_id)
if self.contact_date and getdate(self.contact_date) < getdate(
nowdate()):
dataent.throw(_("Next Contact Date cannot be in the past"))
if self.ends_on and self.contact_date and\
(self.ends_on < self.contact_date):
dataent.throw(
_("Ends On date cannot be before Next Contact Date."))
def get_usage_info():
'''Get data to show for Usage Info'''
# imported here to prevent circular import
from dataent.email.queue import get_emails_sent_this_month
limits = get_limits()
if not (limits and any(
[limits.users, limits.space, limits.emails, limits.expiry])):
# no limits!
return
limits.space = (limits.space or 0) * 1024.0 # to MB
if not limits.space_usage:
# hack! to show some progress
limits.space_usage = {
'database_size': 26,
'files_size': 1,
'backup_size': 1,
'total': 28
}
usage_info = dataent._dict({
'limits': limits,
'enabled_users': len(get_enabled_system_users()),
'emails_sent': get_emails_sent_this_month(),
'space_usage': limits.space_usage['total'],
})
if limits.expiry:
usage_info['expires_on'] = formatdate(limits.expiry)
usage_info['days_to_expiry'] = (getdate(limits.expiry) -
getdate()).days
if limits.upgrade_url:
usage_info['upgrade_url'] = get_upgrade_url(limits.upgrade_url)
return usage_info
def create_salary_slips(self):
"""
Creates salary slip for selected employees if already not created
"""
self.check_permission('write')
self.created = 1
emp_list = [d.employee for d in self.get_emp_list()]
if emp_list:
args = dataent._dict({
"salary_slip_based_on_timesheet":
self.salary_slip_based_on_timesheet,
"payroll_frequency":
self.payroll_frequency,
"start_date":
self.start_date,
"end_date":
self.end_date,
"company":
self.company,
"posting_date":
self.posting_date,
"deduct_tax_for_unclaimed_employee_benefits":
self.deduct_tax_for_unclaimed_employee_benefits,
"deduct_tax_for_unsubmitted_tax_exemption_proof":
self.deduct_tax_for_unsubmitted_tax_exemption_proof,
"payroll_entry":
self.name
})
if len(emp_list) > 30:
dataent.enqueue(create_salary_slips_for_employees,
timeout=600,
employees=emp_list,
args=args)
else:
create_salary_slips_for_employees(emp_list,
args,
publish_progress=False)
def make_quotation(**args):
qo = dataent.new_doc("Quotation")
args = dataent._dict(args)
if args.transaction_date:
qo.transaction_date = args.transaction_date
qo.company = args.company or "_Test Company"
qo.party_name = args.party_name or "_Test Customer"
qo.currency = args.currency or "INR"
if args.selling_price_list:
qo.selling_price_list = args.selling_price_list
if "warehouse" not in args:
args.warehouse = "_Test Warehouse - _TC"
if args.item_list:
for item in args.item_list:
qo.append("items", item)
else:
qo.append(
"items", {
"item_code": args.item or args.item_code or "_Test Item",
"warehouse": args.warehouse,
"qty": args.qty or 10,
"uom": args.uom or None,
"rate": args.rate or 100
})
qo.delivery_date = add_days(qo.transaction_date, 10)
if not args.do_not_save:
qo.insert()
if not args.do_not_submit:
qo.submit()
return qo
def make_blanket_order(**args):
args = dataent._dict(args)
bo = dataent.new_doc("Blanket Order")
bo.blanket_order_type = args.blanket_order_type
bo.company = args.company or "_Test Company"
if args.blanket_order_type == "Selling":
bo.customer = args.customer or "_Test Customer"
else:
bo.supplier = args.supplier or "_Test Supplier"
bo.from_date = today()
bo.to_date = add_months(bo.from_date, months=12)
bo.append(
"items", {
"item_code": args.item_code or "_Test Item",
"qty": args.quantity or 1000,
"rate": args.rate or 100
})
bo.insert()
bo.submit()
return bo
def prepare_data(accounts, fiscal_year, balance_must_be, companies, company_currency):
data = []
year_start_date = fiscal_year.year_start_date
year_end_date = fiscal_year.year_end_date
for d in accounts:
# add to output
has_value = False
total = 0
row = dataent._dict({
"account_name": _(d.account_name),
"account": _(d.account_name),
"parent_account": _(d.parent_account),
"indent": flt(d.indent),
"year_start_date": year_start_date,
"year_end_date": year_end_date,
"currency": company_currency,
"opening_balance": d.get("opening_balance", 0.0) * (1 if balance_must_be == "Debit" else -1)
})
for company in companies:
if d.get(company) and balance_must_be == "Credit":
# change sign based on Debit or Credit, since calculation is done using (debit - credit)
d[company] *= -1
row[company] = flt(d.get(company, 0.0), 3)
if abs(row[company]) >= 0.005:
# ignore zero values
has_value = True
total += flt(row[company])
row["has_value"] = has_value
row["total"] = total
data.append(row)
return data
def flush(from_test=False):
"""flush email queue, every time: called from scheduler"""
# additional check
check_email_limit([])
auto_commit = not from_test
if dataent.are_emails_muted():
msgprint(_("Emails are muted"))
from_test = True
smtpserver_dict = dataent._dict()
for email in get_queue():
if cint(dataent.defaults.get_defaults().get("hold_queue"))==1:
break
if email.name:
smtpserver = smtpserver_dict.get(email.sender)
if not smtpserver:
smtpserver = SMTPServer()
smtpserver_dict[email.sender] = smtpserver
send_one(email.name, smtpserver, auto_commit, from_test=from_test)
def get_list_context(context=None):
filters = dict(published=1)
category = dataent.db.get_value("Help Category",
{"route": dataent.local.path})
if category:
filters['category'] = category
list_context = dataent._dict(title=category or _("Knowledge Base"),
get_level_class=get_level_class,
show_sidebar=True,
sidebar_items=get_sidebar_items(),
hide_filters=True,
filters=filters,
category=dataent.local.form_dict.category,
no_breadcrumbs=True)
if dataent.local.form_dict.txt:
list_context.blog_subtitle = _('Filtered by "{0}"').format(
dataent.local.form_dict.txt)
#
# list_context.update(dataent.get_doc("Blog Settings", "Blog Settings").as_dict())
return list_context
def notify(self, args):
args = dataent._dict(args)
# args -> message, message_to, subject
if cint(self.follow_via_email):
contact = args.message_to
if not isinstance(contact, list):
if not args.notify == "employee":
contact = dataent.get_doc('User', contact).email or contact
sender = dict()
sender['email'] = dataent.get_doc('User',
dataent.session.user).email
sender['full_name'] = dataent.utils.get_fullname(sender['email'])
try:
dataent.sendmail(
recipients=contact,
sender=sender['email'],
subject=args.subject,
message=args.message,
)
dataent.msgprint(_("Email sent to {0}").format(contact))
except dataent.OutgoingEmailError:
pass
def add_user_permissions(data):
''' Add and update the user permissions '''
dataent.only_for('System Manager')
if isinstance(data, dataent.string_types):
data = json.loads(data)
data = dataent._dict(data)
d = check_applicable_doc_perm(data.user, data.doctype, data.docname)
exists = dataent.db.exists(
"User Permission", {
"user": data.user,
"allow": data.doctype,
"for_value": data.docname,
"apply_to_all_doctypes": 1
})
if data.apply_to_all_doctypes == 1 and not exists:
remove_applicable(d, data.user, data.doctype, data.docname)
insert_user_perm(data.user, data.doctype, data.docname, apply_to_all=1)
return 1
elif len(data.applicable_doctypes) > 0 and data.apply_to_all_doctypes != 1:
remove_apply_to_all(data.user, data.doctype, data.docname)
update_applicable(d, data.applicable_doctypes, data.user, data.doctype,
data.docname)
for applicable in data.applicable_doctypes:
if applicable not in d:
insert_user_perm(data.user,
data.doctype,
data.docname,
applicable=applicable)
elif exists:
insert_user_perm(data.user,
data.doctype,
data.docname,
applicable=applicable)
return 1
return 0
def execute(filters=None):
if not filters: filters = {}
validate_filters(filters)
columns = get_columns(filters)
entries = get_entries(filters)
invoice_details = get_invoice_posting_date_map(filters)
data = []
for d in entries:
invoice = invoice_details.get(d.against_voucher) or dataent._dict()
if d.reference_type == "Purchase Invoice":
payment_amount = flt(d.debit) or -1 * flt(d.credit)
else:
payment_amount = flt(d.credit) or -1 * flt(d.debit)
row = [
d.voucher_type, d.voucher_no, d.party_type, d.party,
d.posting_date, d.against_voucher, invoice.posting_date,
invoice.due_date, d.debit, d.credit, d.remarks
]
if d.against_voucher:
row += get_ageing_data(30, 60, 90, 120, d.posting_date,
invoice.posting_date, payment_amount)
else:
row += ["", "", "", "", ""]
if invoice.due_date:
row.append(
(getdate(d.posting_date) - getdate(invoice.due_date)).days
or 0)
data.append(row)
return columns, data
def execute():
dataent.reload_doctype("Holiday List")
default_holiday_list = dataent.db.get_value("Holiday List",
{"is_default": 1})
if default_holiday_list:
for company in dataent.get_all("Company",
fields=["name",
"default_holiday_list"]):
if not company.default_holiday_list:
dataent.db.set_value("Company", company.name,
"default_holiday_list",
default_holiday_list)
fiscal_years = dataent._dict((fy.name, fy) for fy in dataent.get_all(
"Fiscal Year", fields=["name", "year_start_date", "year_end_date"]))
for holiday_list in dataent.get_all("Holiday List",
fields=["name", "fiscal_year"]):
fy = fiscal_years[holiday_list.fiscal_year]
dataent.db.set_value("Holiday List", holiday_list.name, "from_date",
fy.year_start_date)
dataent.db.set_value("Holiday List", holiday_list.name, "to_date",
fy.year_end_date)
