def before_tests():
frappe.clear_cache()
# complete setup if missing
from frappe.desk.page.setup_wizard.setup_wizard import setup_complete
if not frappe.get_list("Company"):
setup_complete({
"currency" :"USD",
"first_name" :"Test",
"last_name" :"User",
"company_name" :"Wind Power LLC",
"timezone" :"America/New_York",
"company_abbr" :"WP",
"industry" :"Manufacturing",
"country" :"United States",
"fy_start_date" :"2014-01-01",
"fy_end_date" :"2014-12-31",
"language" :"english",
"company_tagline" :"Testing",
"email" :"*****@*****.**",
"password" :"test",
"chart_of_accounts" : "Standard"
})
frappe.db.sql("delete from `tabLeave Allocation`")
frappe.db.sql("delete from `tabLeave Application`")
frappe.db.sql("delete from `tabSalary Slip`")
frappe.db.sql("delete from `tabItem Price`")
frappe.db.set_value("Stock Settings", None, "auto_insert_price_list_rate_if_missing", 0)
frappe.db.commit()
def update_global_settings(args): if args.language and args.language != "english": set_default_language(get_language_code(args.lang)) frappe.clear_cache() update_system_settings(args) update_user_name(args)
def setup_complete(args=None):
if frappe.db.sql("select name from tabCompany"):
frappe.throw(_("Setup Already Complete!!"))
install_fixtures.install(args.get("country"))
update_user_name(args)
create_fiscal_year_and_company(args)
create_users(args)
set_defaults(args)
create_territories()
create_price_lists(args)
create_feed_and_todo()
create_email_digest()
create_letter_head(args)
create_taxes(args)
create_items(args)
create_customers(args)
create_suppliers(args)
frappe.local.message_log = []
website_maker(args.company_name.strip(), args.company_tagline, args.name)
create_logo(args)
frappe.db.commit()
login_as_first_user(args)
frappe.db.commit()
frappe.clear_cache()
if args.get("add_sample_data"):
try:
make_sample_data()
frappe.clear_cache()
except FiscalYearError:
pass
def on_update(self):
"""update defaults"""
for key in keydict:
frappe.db.set_default(key, self.get(keydict[key], ''))
# update year start date and year end date from fiscal_year
year_start_end_date = frappe.db.sql("""select year_start_date, year_end_date
from `tabFiscal Year` where name=%s""", self.current_fiscal_year)
if year_start_end_date:
ysd = year_start_end_date[0][0] or ''
yed = year_start_end_date[0][1] or ''
if ysd and yed:
frappe.db.set_default('year_start_date', ysd.strftime('%Y-%m-%d'))
frappe.db.set_default('year_end_date', yed.strftime('%Y-%m-%d'))
# enable default currency
if self.default_currency:
frappe.db.set_value("Currency", self.default_currency, "enabled", 1)
self.toggle_rounded_total()
self.toggle_in_words()
# clear cache
frappe.clear_cache()
def test_save_customization_idx(self):
d = self.get_customize_form("User")
original_sequence = [df.fieldname for df in d.get("fields")]
# move field to last
location_field = d.get("fields", {"fieldname": "location"})[0]
d.get("fields").remove(location_field)
d.append("fields", location_field)
d.run_method("save_customization")
frappe.clear_cache(doctype=d.doc_type)
property_setter_name, _idx = frappe.db.get_value(
"Property Setter", {"doc_type": d.doc_type, "property": "_idx"}, ("name", "value")
)
self.assertTrue(_idx)
_idx = json.loads(_idx)
for i, df in enumerate(frappe.get_meta(d.doc_type).get("fields")):
self.assertEquals(_idx[i], df.fieldname)
frappe.delete_doc("Property Setter", property_setter_name)
frappe.clear_cache(doctype=d.doc_type)
for i, df in enumerate(frappe.get_meta(d.doc_type).get("fields")):
self.assertEquals(original_sequence[i], df.fieldname)
def clear_cache(): import frappe.sessions from frappe.core.doctype.notification_count.notification_count import clear_notifications frappe.connect() frappe.clear_cache() clear_notifications() frappe.destroy()
def on_update(self):
# owner is always name
frappe.db.set(self, 'owner', self.name)
# clear new password
new_password = self.new_password
self.db_set("new_password", "")
clear_notifications(user=self.name)
frappe.clear_cache(user=self.name)
try:
if self.in_insert:
if self.name not in STANDARD_USERS:
if new_password:
# new password given, no email required
_update_password(self.name, new_password)
if not getattr(self, "no_welcome_mail", False):
self.send_welcome_mail()
msgprint(_("Welcome email sent"))
return
else:
self.email_new_password(new_password)
except frappe.OutgoingEmailError:
pass # email server not set, don't send email
def before_tests():
if len(frappe.get_installed_apps()) > 1:
# don't run before tests if any other app is installed
return
frappe.db.sql("delete from `tabCustom Field`")
frappe.db.sql("delete from `tabEvent`")
frappe.db.commit()
frappe.clear_cache()
# complete setup if missing
from frappe.desk.page.setup_wizard.setup_wizard import setup_complete
if not int(frappe.db.get_single_value('System Settings', 'setup_complete') or 0):
setup_complete({
"language" :"english",
"email" :"*****@*****.**",
"full_name" :"Test User",
"password" :"test",
"country" :"United States",
"timezone" :"America/New_York",
"currency" :"USD"
})
frappe.db.commit()
frappe.clear_cache()
def on_trash(self):
frappe.clear_cache(user=self.name)
if self.name in STANDARD_USERS:
throw(_("User {0} cannot be deleted").format(self.name))
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.enabled = 0
if getattr(frappe.local, "login_manager", None):
frappe.local.login_manager.logout(user=self.name)
# delete their password
frappe.db.sql("""delete from __Auth where user=%s""", (self.name,))
# delete todos
frappe.db.sql("""delete from `tabToDo` where owner=%s""", (self.name,))
frappe.db.sql("""update tabToDo set assigned_by=null where assigned_by=%s""",
(self.name,))
# delete events
frappe.db.sql("""delete from `tabEvent` where owner=%s
and event_type='Private'""", (self.name,))
# delete messages
frappe.db.sql("""delete from `tabComment` where comment_doctype='Message'
and (comment_docname=%s or owner=%s)""", (self.name, self.name))
def on_update(self): if hasattr(self, 'old_doc_type') and self.old_doc_type: frappe.clear_cache(doctype=self.old_doc_type) if self.doc_type: frappe.clear_cache(doctype=self.doc_type) self.export_doc()
def load_messages(language):
frappe.clear_cache()
set_default_language(language)
m = get_dict("page", "setup-wizard")
m.update(get_dict("boot"))
send_translations(m)
return frappe.local.lang
def setup_domain(domain):
if not domain in domains:
return
from frappe.desk.doctype.desktop_icon.desktop_icon import set_desktop_icons
data = frappe._dict(domains[domain])
if data.remove_roles:
for role in data.remove_roles:
frappe.db.sql('delete from tabUserRole where role=%s', role)
if data.desktop_icons:
set_desktop_icons(data.desktop_icons)
if data.properties:
for args in data.properties:
frappe.make_property_setter(args)
if data.set_value:
for args in data.set_value:
doc = frappe.get_doc(args[0], args[1] or args[0])
doc.set(args[2], args[3])
doc.save()
frappe.clear_cache()
def reset_to_defaults(self):
if not self.doc_type:
return
frappe.db.sql("""delete from `tabProperty Setter` where doc_type=%s""", self.doc_type)
frappe.clear_cache(doctype=self.doc_type)
self.fetch_to_customize()
def on_trash(self):
frappe.clear_cache(user=self.name)
if self.name in STANDARD_USERS:
throw(_("User {0} cannot be deleted").format(self.name))
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.enabled = 0
if getattr(frappe.local, "login_manager", None):
frappe.local.login_manager.logout(user=self.name)
# delete todos
frappe.db.sql("""delete from `tabToDo` where owner=%s""", (self.name,))
frappe.db.sql("""update tabToDo set assigned_by=null where assigned_by=%s""",
(self.name,))
# delete events
frappe.db.sql("""delete from `tabEvent` where owner=%s
and event_type='Private'""", (self.name,))
# delete shares
frappe.db.sql("""delete from `tabDocShare` where user=%s""", self.name)
# delete messages
frappe.db.sql("""delete from `tabCommunication`
where communication_type in ('Chat', 'Notification')
and reference_doctype='User'
and (reference_name=%s or owner=%s)""", (self.name, self.name))
def post_install(rebuild_website=False): if rebuild_website: render.clear_cache() init_singles() frappe.db.commit() frappe.clear_cache()
def reset_perms():
frappe.connect()
for d in frappe.db.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
frappe.clear_cache(doctype=d)
frappe.reset_perms(d)
frappe.destroy()
def clear_doctype_cache(doctype):
frappe.clear_cache(doctype=doctype)
delete_notification_count_for(doctype)
for user in frappe.db.sql_list("""select distinct tabUserRole.parent from tabUserRole, tabDocPerm
where tabDocPerm.parent = %s
and tabDocPerm.role = tabUserRole.role""", doctype):
frappe.clear_cache(user=user)
def tearDown(self):
frappe.db.sql('delete from `tabProperty Setter` where doc_type="Event"')
frappe.clear_cache(doctype='Event')
frappe.db.sql('delete from `tabEvent`')
frappe.db.sql('delete from __global_search')
make_test_objects('Event')
frappe.db.commit()
def on_update(self):
if not frappe.db.sql("""select name from tabAccount
where company=%s and docstatus<2 limit 1""", self.name):
if not frappe.local.flags.ignore_chart_of_accounts:
self.create_default_accounts()
self.create_default_warehouses()
self.install_country_fixtures()
if not frappe.db.get_value("Cost Center", {"is_group": 0, "company": self.name}):
self.create_default_cost_center()
if not frappe.local.flags.ignore_chart_of_accounts:
self.set_default_accounts()
if self.default_cash_account:
self.set_mode_of_payment_account()
if self.default_currency:
frappe.db.set_value("Currency", self.default_currency, "enabled", 1)
if hasattr(frappe.local, 'enable_perpetual_inventory') and \
self.name in frappe.local.enable_perpetual_inventory:
frappe.local.enable_perpetual_inventory[self.name] = self.enable_perpetual_inventory
frappe.clear_cache()
def setup(domain):
complete_setup(domain)
setup_demo_page()
setup_fiscal_year()
setup_holiday_list()
setup_user()
setup_employee()
setup_salary_structure()
setup_salary_structure_for_timesheet()
setup_leave_allocation()
setup_user_roles()
setup_customer()
setup_supplier()
setup_warehouse()
import_json('Address')
import_json('Contact')
import_json('Lead')
setup_currency_exchange()
setup_mode_of_payment()
setup_account_to_expense_type()
setup_budget()
setup_pos_profile()
frappe.db.commit()
frappe.clear_cache()
def setup(domain):
complete_setup(domain)
setup_demo_page()
setup_fiscal_year()
setup_holiday_list()
setup_user()
setup_employee()
setup_user_roles()
employees = frappe.get_all('Employee', fields=['name', 'date_of_joining'])
# monthly salary
setup_salary_structure(employees[:5], 0)
# based on timesheet
setup_salary_structure(employees[5:], 1)
setup_leave_allocation()
setup_customer()
setup_supplier()
setup_warehouse()
import_json('Address')
import_json('Contact')
import_json('Lead')
setup_currency_exchange()
#setup_mode_of_payment()
setup_account_to_expense_type()
setup_budget()
setup_pos_profile()
frappe.db.commit()
frappe.clear_cache()
def validate_currency(self):
self.previous_default_currency = frappe.db.get_value("Company", self.name, "default_currency")
if self.default_currency and self.previous_default_currency and \
self.default_currency != self.previous_default_currency :
frappe.throw(_("Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency."))
if frappe.flags.country_change:
install_country_fixtures(self.name)
#if not frappe.db.get_value("Cost Center", {"is_group": 0, "company": self.name}):
#self.create_default_cost_center()
#if not frappe.local.flags.ignore_chart_of_accounts:
#self.set_default_accounts()
#if self.default_cash_account:
#self.set_mode_of_payment_account()
if self.default_currency:
frappe.db.set_value("Currency", self.default_currency, "enabled", 1)
#if hasattr(frappe.local, 'enable_perpetual_inventory') and \
#self.name in frappe.local.enable_perpetual_inventory:
#frappe.local.enable_perpetual_inventory[self.name] = self.enable_perpetual_inventory
frappe.clear_cache()
def setup_complete(args):
"""Calls hooks for `setup_wizard_complete`, sets home page as `desktop`
and clears cache. If wizard breaks, calls `setup_wizard_exception` hook"""
args = process_args(args)
try:
if args.language and args.language != "english":
set_default_language(args.language)
frappe.clear_cache()
# update system settings
update_system_settings(args)
for method in frappe.get_hooks("setup_wizard_complete"):
frappe.get_attr(method)(args)
# frappe.db.set_default('desktop:home_page', 'desktop')
frappe.db.set_default('desktop:home_page', 'dashboard')
frappe.db.commit()
frappe.clear_cache()
except:
if args:
traceback = frappe.get_traceback()
for hook in frappe.get_hooks("setup_wizard_exception"):
frappe.get_attr(hook)(traceback, args)
raise
else:
for hook in frappe.get_hooks("setup_wizard_success"):
frappe.get_attr(hook)(args)
def on_update(self): """update defaults""" for key in education_keydict: frappe.db.set_default(key, self.get(education_keydict[key], '')) # clear cache frappe.clear_cache()
def validate(self):
if self.disabled:
if self.name in ("Guest", "Administrator", "System Manager", "All"):
frappe.throw(frappe._("Standard roles cannot be disabled"))
else:
frappe.db.sql("delete from `tabUserRole` where role = %s", self.name)
frappe.clear_cache()
def on_update(self):
NestedSet.on_update(self)
if not frappe.db.sql("""select name from tabAccount
where company=%s and docstatus<2 limit 1""", self.name):
if not frappe.local.flags.ignore_chart_of_accounts:
frappe.flags.country_change = True
self.create_default_accounts()
self.create_default_warehouses()
if frappe.flags.country_change:
install_country_fixtures(self.name)
self.create_default_tax_template()
if not frappe.db.get_value("Department", {"company": self.name}):
from erpnext.setup.setup_wizard.operations.install_fixtures import install_post_company_fixtures
install_post_company_fixtures(frappe._dict({'company_name': self.name}))
if not frappe.db.get_value("Cost Center", {"is_group": 0, "company": self.name}):
self.create_default_cost_center()
if not frappe.local.flags.ignore_chart_of_accounts:
self.set_default_accounts()
if self.default_cash_account:
self.set_mode_of_payment_account()
if self.default_currency:
frappe.db.set_value("Currency", self.default_currency, "enabled", 1)
if hasattr(frappe.local, 'enable_perpetual_inventory') and \
self.name in frappe.local.enable_perpetual_inventory:
frappe.local.enable_perpetual_inventory[self.name] = self.enable_perpetual_inventory
frappe.clear_cache()
def on_update(self):
"""Update database schema, make controller templates if `custom` is not set and clear cache."""
from frappe.model.db_schema import updatedb
updatedb(self.name, self)
self.change_modified_of_parent()
make_module_and_roles(self)
self.update_fields_to_fetch()
from frappe import conf
if not self.custom and not (frappe.flags.in_import or frappe.flags.in_test) and conf.get('developer_mode'):
self.export_doc()
self.make_controller_template()
if self.has_web_view:
self.set_base_class_for_controller()
# update index
if not self.custom:
self.run_module_method("on_doctype_update")
if self.flags.in_insert:
self.run_module_method("after_doctype_insert")
delete_notification_count_for(doctype=self.name)
frappe.clear_cache(doctype=self.name)
if not frappe.flags.in_install and hasattr(self, 'before_update'):
self.sync_global_search()
# clear from local cache
if self.name in frappe.local.meta_cache:
del frappe.local.meta_cache[self.name]
def on_update(self): # clear new password self.validate_user_limit() self.share_with_self() clear_notifications(user=self.name) frappe.clear_cache(user=self.name) self.send_password_notification(self.__new_password)
def test_fetch_if_empty(self):
frappe.db.sql('delete from tabToDo')
# Allow user changes
todo_meta = frappe.get_doc('DocType', 'ToDo')
field = todo_meta.get('fields', dict(fieldname='assigned_by_full_name'))[0]
field.fetch_from = 'assigned_by.full_name'
field.fetch_if_empty = 1
todo_meta.save()
frappe.clear_cache(doctype='ToDo')
todo = frappe.get_doc(dict(doctype='ToDo', description='test todo',
assigned_by='Administrator', assigned_by_full_name='Admin')).insert()
self.assertEqual(todo.assigned_by_full_name, 'Admin')
# Overwrite user changes
todo_meta = frappe.get_doc('DocType', 'ToDo')
todo_meta.get('fields', dict(fieldname='assigned_by_full_name'))[0].fetch_if_empty = 0
todo_meta.save()
todo.reload()
todo.save()
self.assertEqual(todo.assigned_by_full_name,
frappe.db.get_value('User', todo.assigned_by, 'full_name'))
def main(app=None, module=None, doctype=None, verbose=False, tests=(), force=False):
frappe.flags.print_messages = verbose
frappe.flags.in_test = True
if not frappe.db:
frappe.connect()
# if not frappe.conf.get("db_name").startswith("test_"):
# raise Exception, 'db_name must start with "test_"'
# workaround! since there is no separate test db
frappe.clear_cache()
frappe.utils.scheduler.disable_scheduler()
set_test_email_config()
if verbose:
print 'Running "before_tests" hooks'
for fn in frappe.get_hooks("before_tests", app_name=app):
frappe.get_attr(fn)()
if doctype:
ret = run_tests_for_doctype(doctype, verbose=verbose, tests=tests, force=force)
elif module:
ret = run_tests_for_module(module, verbose=verbose, tests=tests)
else:
ret = run_all_tests(app, verbose)
frappe.db.commit()
# workaround! since there is no separate test db
frappe.clear_cache()
return ret
def setUp(self):
frappe.clear_cache(doctype="Blog Post")
if not frappe.flags.permission_user_setup_done:
user = frappe.get_doc("User", "*****@*****.**")
user.add_roles("Website Manager")
user.add_roles("System Manager")
user = frappe.get_doc("User", "*****@*****.**")
user.add_roles("Blogger")
user = frappe.get_doc("User", "*****@*****.**")
user.add_roles("Sales User")
frappe.flags.permission_user_setup_done = True
reset('Blogger')
reset('Blog Post')
frappe.db.sql('delete from `tabUser Permission`')
frappe.set_user("*****@*****.**")
def toggle_disabling(doc):
doc = json.loads(doc)
if doc.get('disabled'):
df = {"read_only": 1}
else:
df = {"read_only": 0}
doclist = get_doctypes_with_dimensions()
for doctype in doclist:
field = frappe.db.get_value("Custom Field", {
"dt": doctype,
"fieldname": doc.get('fieldname')
})
if field:
custom_field = frappe.get_doc("Custom Field", field)
custom_field.update(df)
custom_field.save()
frappe.clear_cache(doctype=doctype)
def main(app=None,
module=None,
doctype=None,
verbose=False,
tests=(),
force=False):
frappe.flags.print_messages = verbose
frappe.flags.in_test = True
if not frappe.db:
frappe.connect()
# if not frappe.conf.get("db_name").startswith("test_"):
# raise Exception, 'db_name must start with "test_"'
# workaround! since there is no separate test db
frappe.clear_cache()
set_test_email_config()
if verbose:
print 'Running "before_tests" hooks'
for fn in frappe.get_hooks("before_tests", app_name=app):
frappe.get_attr(fn)()
if doctype:
ret = run_tests_for_doctype(doctype,
verbose=verbose,
tests=tests,
force=force)
elif module:
ret = run_tests_for_module(module, verbose=verbose, tests=tests)
else:
ret = run_all_tests(app, verbose)
frappe.db.commit()
# workaround! since there is no separate test db
frappe.clear_cache()
return ret
def set_series_for(self, doctype, ol):
options = self.scrub_options_list(ol)
# validate names
for i in options:
self.validate_series_name(i)
if self.user_must_always_select:
options = [''] + options
default = ''
else:
default = options[0]
# update in property setter
prop_dict = {'options': "\n".join(options), 'default': default}
for prop in prop_dict:
ps_exists = frappe.db.sql(
"""SELECT name FROM `tabProperty Setter`
WHERE doc_type = %s AND field_name = 'naming_series'
AND property = %s""", (doctype, prop))
if ps_exists:
ps = frappe.get_doc('Property Setter', ps_exists[0][0])
ps.value = prop_dict[prop]
ps.save()
else:
ps = frappe.get_doc({
'doctype': 'Property Setter',
'doctype_or_field': 'DocField',
'doc_type': doctype,
'field_name': 'naming_series',
'property': prop,
'value': prop_dict[prop],
'property_type': 'Text',
'__islocal': 1
})
ps.save()
self.set_options = "\n".join(options)
frappe.clear_cache(doctype=doctype)
def set_series_for(self, doctype, ol):
options = list(self.scrub_options_list(ol))
# validate names #
for i in options: self.validate_series_name(i)
if options and self.user_must_always_select:
options = [''] + options
##default = options[0] if options else ''
default = (options[0])
# update in property setter
prop_dict = {'options': "\n".join(options), 'default': default}
for prop in prop_dict:
ps_exists = frappe.db.get_value("Property Setter",
{"field_name": 'naming_series', 'doc_type': doctype, 'property': prop})
if ps_exists:
ps = frappe.get_doc('Property Setter', ps_exists)
ps.value = prop_dict[prop]
ps.save()
else:
ps = frappe.get_doc({
'doctype': 'Property Setter',
'doctype_or_field': 'DocField',
'doc_type': doctype,
'field_name': 'naming_series',
'property': prop,
'value': prop_dict[prop],
'property_type': 'Text',
'__islocal': 1
})
ps.save()
self.set_options = "\n".join(options)
frappe.clear_cache(doctype=doctype)
def on_trash(self):
frappe.clear_cache(user=self.name)
if self.name in STANDARD_USERS:
throw(_("User {0} cannot be deleted").format(self.name))
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.enabled = 0
if getattr(frappe.local, "login_manager", None):
frappe.local.login_manager.logout(user=self.name)
# delete todos
frappe.db.delete("ToDo", {"owner": self.name})
frappe.db.sql("""UPDATE `tabToDo` SET `assigned_by`=NULL WHERE `assigned_by`=%s""",
(self.name,))
# delete events
frappe.db.delete("Event", {"owner": self.name, "event_type": "Private"})
# delete shares
frappe.db.delete("DocShare", {"user": self.name})
# delete messages
frappe.db.sql("""delete from `tabCommunication`
where communication_type in ('Chat', 'Notification')
and reference_doctype='User'
and (reference_name=%s or owner=%s)""", (self.name, self.name))
# unlink contact
frappe.db.sql("""update `tabContact`
set `user`=null
where `user`=%s""", (self.name))
# delete notification settings
frappe.delete_doc("Notification Settings", self.name, ignore_permissions=True)
if self.get('allow_in_mentions'):
frappe.cache().delete_key('users_for_mentions')
frappe.cache().delete_key('enabled_users')
def on_update(self):
NestedSet.on_update(self)
if not frappe.db.sql(
"""select name from tabAccount
where company=%s and docstatus<2 limit 1""", self.name):
if not frappe.local.flags.ignore_chart_of_accounts:
frappe.flags.country_change = True
self.create_default_accounts()
self.create_default_warehouses()
if frappe.flags.country_change:
install_country_fixtures(self.name)
self.create_default_tax_template()
if not frappe.db.get_value("Department", {"company": self.name}):
from erpnext.setup.setup_wizard.operations.install_fixtures import install_post_company_fixtures
install_post_company_fixtures(
frappe._dict({'company_name': self.name}))
if not frappe.db.get_value("Cost Center", {
"is_group": 0,
"company": self.name
}):
self.create_default_cost_center()
if not frappe.local.flags.ignore_chart_of_accounts:
self.set_default_accounts()
if self.default_cash_account:
self.set_mode_of_payment_account()
if self.default_currency:
frappe.db.set_value("Currency", self.default_currency, "enabled",
1)
if hasattr(frappe.local, 'enable_perpetual_inventory') and \
self.name in frappe.local.enable_perpetual_inventory:
frappe.local.enable_perpetual_inventory[
self.name] = self.enable_perpetual_inventory
frappe.clear_cache()
def setup_complete(args=None):
if frappe.db.sql("select name from tabCompany"):
frappe.throw(_("Setup Already Complete!!"))
install_fixtures.install(args.get("country"))
update_setup_wizard_access()
create_fiscal_year_and_company(args)
create_users(args)
set_defaults(args)
create_territories()
create_price_lists(args)
create_feed_and_todo()
create_email_digest()
create_letter_head(args)
create_taxes(args)
create_items(args)
create_customers(args)
create_suppliers(args)
frappe.local.message_log = []
setup_domain(args.get('domain'))
website_maker(args)
create_logo(args)
frappe.db.commit()
login_as_first_user(args)
frappe.db.commit()
frappe.clear_cache()
if args.get("add_sample_data"):
try:
make_sample_data()
frappe.clear_cache()
except:
# clear message
if frappe.message_log:
frappe.message_log.pop()
pass
def on_update(self):
"""Update database schema, make controller templates if `custom` is not set and clear cache."""
self.delete_duplicate_custom_fields()
try:
frappe.db.updatedb(self.name, self)
except Exception as e:
print("\n\nThere was an issue while migrating the DocType: {}\n".format(self.name))
raise e
self.change_modified_of_parent()
make_module_and_roles(self)
self.update_fields_to_fetch()
from frappe import conf
allow_doctype_export = frappe.flags.allow_doctype_export or (not frappe.flags.in_test and conf.get('developer_mode'))
if not self.custom and not frappe.flags.in_import and allow_doctype_export:
self.export_doc()
self.make_controller_template()
if self.has_web_view:
self.set_base_class_for_controller()
# update index
if not self.custom:
self.run_module_method("on_doctype_update")
if self.flags.in_insert:
self.run_module_method("after_doctype_insert")
delete_notification_count_for(doctype=self.name)
frappe.clear_cache(doctype=self.name)
if not frappe.flags.in_install and hasattr(self, 'before_update'):
self.sync_global_search()
# clear from local cache
if self.name in frappe.local.meta_cache:
del frappe.local.meta_cache[self.name]
clear_linked_doctype_cache()
def complete_setup():
print "Complete Setup..."
from frappe.desk.page.setup_wizard.setup_wizard import setup_complete
setup_complete({
"first_name": "Test",
"last_name": "User",
"email": "*****@*****.**",
"company_tagline": "Wind Mills for a Better Tomorrow",
"password": "******",
"fy_start_date": "2015-01-01",
"fy_end_date": "2015-12-31",
"industry": "Manufacturing",
"company_name": settings.company,
"chart_of_accounts": "Standard",
"company_abbr": settings.company_abbr,
"currency": settings.currency,
"timezone": settings.time_zone,
"country": settings.country,
"language": "english"
})
# home page should always be "start"
website_settings = frappe.get_doc("Website Settings", "Website Settings")
website_settings.home_page = "start"
website_settings.save()
for year in xrange(2014, frappe.utils.now_datetime().year + 1, 1):
try:
frappe.get_doc({
"doctype": "Fiscal Year",
"year": frappe.utils.cstr(year),
"year_start_date": "{0}-01-01".format(year),
"year_end_date": "{0}-12-31".format(year)
}).insert()
except frappe.DuplicateEntryError:
pass
import_data("Holiday List")
frappe.clear_cache()
def execute():
frappe.reload_doc('core', 'doctype', 'DocField')
if frappe.db.has_column('DocField', 'show_days'):
frappe.db.sql("""
UPDATE
tabDocField
SET
hide_days = 1 WHERE show_days = 0
""")
frappe.db.sql_ddl('alter table tabDocField drop column show_days')
if frappe.db.has_column('DocField', 'show_seconds'):
frappe.db.sql("""
UPDATE
tabDocField
SET
hide_seconds = 1 WHERE show_seconds = 0
""")
frappe.db.sql_ddl('alter table tabDocField drop column show_seconds')
frappe.clear_cache(doctype='DocField')
def update_hr_permissions():
# add set user permissions rights to HR Manager
frappe.db.sql(
"""update `tabDocPerm` set `set_user_permissions`=1 where parent in ('Employee', 'Leave Application')
and role='HR Manager' and permlevel=0 and `read`=1""")
# apply user permissions on Employee and Leave Application
frappe.db.sql(
"""update `tabDocPerm` set `apply_user_permissions`=1 where parent in ('Employee', 'Leave Application')
and role in ('Employee', 'Leave Approver') and permlevel=0 and `read`=1""")
frappe.clear_cache()
# save employees to run on_update events
for employee in frappe.db.sql_list(
"""select name from `tabEmployee` where docstatus < 2"""):
try:
emp = frappe.get_doc("Employee", employee)
emp.flags.ignore_mandatory = True
emp.save()
except EmployeeUserDisabledError:
pass
def on_update(self):
from frappe.model.db_schema import updatedb
updatedb(self.name)
self.change_modified_of_parent()
make_module_and_roles(self)
from frappe import conf
if not (frappe.flags.in_import
or frappe.flags.in_test) and conf.get('developer_mode') or 0:
self.export_doc()
self.make_controller_template()
# update index
if not getattr(self, "custom", False):
from frappe.modules import load_doctype_module
module = load_doctype_module(self.name, self.module)
if hasattr(module, "on_doctype_update"):
module.on_doctype_update()
delete_notification_count_for(doctype=self.name)
frappe.clear_cache(doctype=self.name)
def test_default_values(self):
doc = frappe.new_doc("Blog Post")
self.assertFalse(doc.get("blog_category"))
# Fetch default based on single user permission
add_user_permission("Blog Category", "-test-blog-category-1", "*****@*****.**")
frappe.set_user("*****@*****.**")
doc = frappe.new_doc("Blog Post")
self.assertEqual(doc.get("blog_category"), "-test-blog-category-1")
# Don't fetch default if user permissions is more than 1
add_user_permission("Blog Category", "-test-blog-category", "*****@*****.**", ignore_permissions=True)
frappe.clear_cache()
doc = frappe.new_doc("Blog Post")
self.assertFalse(doc.get("blog_category"))
# Fetch user permission set as default from multiple user permission
add_user_permission("Blog Category", "-test-blog-category-2", "*****@*****.**", ignore_permissions=True, is_default=1)
frappe.clear_cache()
doc = frappe.new_doc("Blog Post")
self.assertEqual(doc.get("blog_category"), "-test-blog-category-2")
def save_customization(self):
if not self.doc_type:
return
self.flags.update_db = False
self.flags.rebuild_doctype_for_global_search = False
self.set_property_setters()
self.update_custom_fields()
self.set_name_translation()
validate_fields_for_doctype(self.doc_type)
if self.flags.update_db:
frappe.db.updatedb(self.doc_type)
if not hasattr(self, 'hide_success') or not self.hide_success:
frappe.msgprint(_("{0} updated").format(_(self.doc_type)), alert=True)
frappe.clear_cache(doctype=self.doc_type)
self.fetch_to_customize()
if self.flags.rebuild_doctype_for_global_search:
frappe.enqueue('frappe.utils.global_search.rebuild_for_doctype',
now=True, doctype=self.doc_type)
def on_update(self):
# clear new password
self.share_with_self()
clear_notifications(user=self.name)
frappe.clear_cache(user=self.name)
now = frappe.flags.in_test or frappe.flags.in_install
self.send_password_notification(self.__new_password)
frappe.enqueue(
"frappe.core.doctype.user.user.create_contact", user=self, ignore_mandatory=True, now=now
)
if self.name not in ("Administrator", "Guest") and not self.user_image:
frappe.enqueue("frappe.core.doctype.user.user.update_gravatar", name=self.name, now=now)
# Set user selected timezone
if self.time_zone:
frappe.defaults.set_default("time_zone", self.time_zone, self.name)
if self.has_value_changed("allow_in_mentions") or self.has_value_changed("user_type"):
frappe.cache().delete_key("users_for_mentions")
if self.has_value_changed("enabled"):
frappe.cache().delete_key("enabled_users")
def on_trash(self):
"""Delete module name from modules.txt"""
if frappe.flags.in_uninstall:
return
modules = None
if frappe.local.module_app.get(frappe.scrub(self.name)):
with open(frappe.get_app_path(self.app_name, "modules.txt"),
"r") as f:
content = f.read()
if self.name in content.splitlines():
modules = list(filter(None, content.splitlines()))
modules.remove(self.name)
if modules:
with open(frappe.get_app_path(self.app_name, "modules.txt"),
"w") as f:
f.write("\n".join(modules))
frappe.clear_cache()
frappe.setup_module_map()
def _reinstall(site, admin_password=None, mariadb_root_username=None, mariadb_root_password=None, yes=False, verbose=False):
from frappe.installer import _new_site
if not yes:
click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.conf.db_name, site, verbose=verbose, force=True, reinstall=True, install_apps=installed,
mariadb_root_username=mariadb_root_username, mariadb_root_password=mariadb_root_password,
admin_password=admin_password)
def create_custom_fields(custom_fields, ignore_validate=False, update=True):
"""Add / update multiple custom fields
:param custom_fields: example `{'Sales Invoice': [dict(fieldname='test')]}`"""
if not ignore_validate and frappe.flags.in_setup_wizard:
ignore_validate = True
for doctypes, fields in custom_fields.items():
if isinstance(fields, dict):
# only one field
fields = [fields]
if isinstance(doctypes, str):
# only one doctype
doctypes = (doctypes, )
for doctype in doctypes:
for df in fields:
field = frappe.db.get_value("Custom Field", {
"dt": doctype,
"fieldname": df["fieldname"]
})
if not field:
try:
df["owner"] = "Administrator"
create_custom_field(doctype,
df,
ignore_validate=ignore_validate)
except frappe.exceptions.DuplicateEntryError:
pass
elif update:
custom_field = frappe.get_doc("Custom Field", field)
custom_field.flags.ignore_validate = ignore_validate
custom_field.update(df)
custom_field.save()
frappe.clear_cache(doctype=doctype)
frappe.db.updatedb(doctype)
def on_trash(self):
frappe.clear_cache(user=self.name)
if self.name in STANDARD_USERS:
throw(_("User {0} cannot be deleted").format(self.name))
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.enabled = 0
if getattr(frappe.local, "login_manager", None):
frappe.local.login_manager.logout(user=self.name)
# delete todos
frappe.db.sql("""delete from `tabToDo` where owner=%s""",
(self.name, ))
frappe.db.sql(
"""update tabToDo set assigned_by=null where assigned_by=%s""",
(self.name, ))
# delete events
frappe.db.sql(
"""delete from `tabEvent` where owner=%s
and event_type='Private'""", (self.name, ))
# delete shares
frappe.db.sql("""delete from `tabDocShare` where user=%s""", self.name)
# delete messages
frappe.db.sql(
"""delete from `tabCommunication`
where communication_type in ('Chat', 'Notification')
and reference_doctype='User'
and (reference_name=%s or owner=%s)""", (self.name, self.name))
# unlink contact
frappe.db.sql(
"""update `tabContact`
set user=null
where user=%s""", (self.name))
def clear_cache(path=None):
'''Clear website caches
:param path: (optional) for the given path'''
for key in ('website_generator_routes', 'website_pages',
'website_full_index'):
frappe.cache().delete_value(key)
frappe.cache().delete_value("website_404")
if path:
frappe.cache().hdel('website_redirects', path)
delete_page_cache(path)
else:
clear_sitemap()
frappe.clear_cache("Guest")
for key in ('portal_menu_items', 'home_page', 'website_route_rules',
'doctypes_with_web_view', 'website_redirects',
'page_context', 'website_page'):
frappe.cache().delete_value(key)
for method in frappe.get_hooks("website_clear_cache"):
frappe.get_attr(method)(path)
def on_update(self):
"""Update database schema, make controller templates if `custom` is not set and clear cache."""
from frappe.model.db_schema import updatedb
updatedb(self.name)
self.change_modified_of_parent()
make_module_and_roles(self)
from frappe import conf
if not self.custom and not (
frappe.flags.in_import
or frappe.flags.in_test) and conf.get('developer_mode'):
self.export_doc()
self.make_controller_template()
# update index
self.run_module_method("on_doctype_update")
if self.flags.in_insert:
self.run_module_method("after_doctype_insert")
delete_notification_count_for(doctype=self.name)
frappe.clear_cache(doctype=self.name)
def setup_complete(args):
"""Calls hooks for `setup_wizard_complete`, sets home page as `desktop`
and clears cache. If wizard breaks, calls `setup_wizard_exception` hook"""
if cint(frappe.db.get_single_value('System Settings', 'setup_complete')):
frappe.throw(_('Setup already complete'))
args = process_args(args)
try:
if args.language and args.language != "english":
set_default_language(get_language_code(args.lang))
frappe.clear_cache()
# update system settings
update_system_settings(args)
update_user_name(args)
for method in frappe.get_hooks("setup_wizard_complete"):
frappe.get_attr(method)(args)
disable_future_access()
frappe.db.commit()
frappe.clear_cache()
except:
frappe.db.rollback()
if args:
traceback = frappe.get_traceback()
for hook in frappe.get_hooks("setup_wizard_exception"):
frappe.get_attr(hook)(traceback, args)
raise
else:
for hook in frappe.get_hooks("setup_wizard_success"):
frappe.get_attr(hook)(args)
def on_trash(self):
frappe.clear_cache(user=self.doc.name)
if self.doc.name in ["Administrator", "Guest"]:
throw(
"{msg}: {name}".format(**{
"msg": _("Hey! You cannot delete user"),
"name": self.doc.name
}))
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.doc.enabled = 0
if getattr(frappe.local, "login_manager", None):
frappe.local.login_manager.logout(user=self.doc.name)
# delete their password
frappe.db.sql("""delete from __Auth where user=%s""",
(self.doc.name, ))
# delete todos
frappe.db.sql("""delete from `tabToDo` where owner=%s""",
(self.doc.name, ))
frappe.db.sql(
"""update tabToDo set assigned_by=null where assigned_by=%s""",
(self.doc.name, ))
# delete events
frappe.db.sql(
"""delete from `tabEvent` where owner=%s
and event_type='Private'""", (self.doc.name, ))
frappe.db.sql("""delete from `tabEvent User` where person=%s""",
(self.doc.name, ))
# delete messages
frappe.db.sql(
"""delete from `tabComment` where comment_doctype='Message'
and (comment_docname=%s or owner=%s)""", (self.doc.name, self.doc.name))
def install_app(name, verbose=False, set_as_patched=True):
frappe.flags.in_install_app = name
frappe.clear_cache()
app_hooks = frappe.get_hooks(app_name=name)
installed_apps = frappe.get_installed_apps()
if name not in frappe.get_all_apps(with_frappe=True):
raise Exception("App not in apps.txt")
if name in installed_apps:
print "App Already Installed"
frappe.msgprint("App {0} already installed".format(name))
return
if name != "frappe":
frappe.only_for("System Manager")
for before_install in app_hooks.before_install or []:
frappe.get_attr(before_install)()
if name != "frappe":
add_module_defs(name)
sync_for(name, force=True, sync_everything=True, verbose=verbose)
add_to_installed_apps(name)
if set_as_patched:
set_all_patches_as_completed(name)
for after_install in app_hooks.after_install or []:
frappe.get_attr(after_install)()
print "Installing Fixtures..."
sync_fixtures(name)
frappe.flags.in_install_app = False
def execute():
accounting_dimensions = frappe.db.get_all(
"Accounting Dimension",
fields=["fieldname", "label", "document_type", "disabled"])
if not accounting_dimensions:
return
count = 1
for d in accounting_dimensions:
if count % 2 == 0:
insert_after_field = "dimension_col_break"
else:
insert_after_field = "accounting_dimensions_section"
for doctype in ["Purchase Order", "Purchase Receipt", "Sales Order"]:
field = frappe.db.get_value("Custom Field", {
"dt": doctype,
"fieldname": d.fieldname
})
if field:
continue
df = {
"fieldname": d.fieldname,
"label": d.label,
"fieldtype": "Link",
"options": d.document_type,
"insert_after": insert_after_field,
}
create_custom_field(doctype, df, ignore_validate=True)
frappe.clear_cache(doctype=doctype)
count += 1
def reinstall(context, admin_password=None, yes=False):
"Reinstall site ie. wipe all data and start over"
if not yes:
click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True)
site = get_site(context)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.conf.db_name, site, verbose=context.verbose, force=True, reinstall=True,
install_apps=installed, admin_password=admin_password)
def reinstall(context):
"Reinstall site ie. wipe all data and start over"
site = get_single_site(context)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.conf.db_name,
site,
verbose=context.verbose,
force=True,
reinstall=True,
install_apps=installed)
def setup_complete(args):
"""Calls hooks for `setup_wizard_complete`, sets home page as `desktop`
and clears cache. If wizard breaks, calls `setup_wizard_exception` hook"""
args = process_args(args)
try:
for method in frappe.get_hooks("setup_wizard_complete"):
frappe.get_attr(method)(args)
frappe.db.set_default('desktop:home_page', 'desktop')
frappe.db.commit()
frappe.clear_cache()
except:
if args:
traceback = frappe.get_traceback()
for hook in frappe.get_hooks("setup_wizard_exception"):
frappe.get_attr(hook)(traceback, args)
raise
else:
for hook in frappe.get_hooks("setup_wizard_success"):
frappe.get_attr(hook)(args)
def delete_currency_from_gl_entry(currency):
doclist = [
scrub(currency), "debit_in_" + scrub(currency),
"credit_in_" + scrub(currency)
]
frappe.db.sql(
"""
DELETE FROM `tabCustom Field`
WHERE fieldname IN (%s)
AND dt = 'GL Entry'""" % #nosec
(', '.join(['%s'] * len(doclist))),
tuple(doclist))
frappe.db.sql(
"""
DELETE FROM `tabProperty Setter`
WHERE field_name IN (%s)
AND doc_type = 'GL Entry'""" % #nosec
(', '.join(['%s'] * len(doclist))),
tuple(doclist))
frappe.clear_cache(doctype="GL Entry")
