-webnotes +frappe 💥
This commit is contained in:
Rushabh Mehta
parent
876d05b081
commit
024ddfcc5b
842 changed files with 6345 additions and 6345 deletions
38
MANIFEST.in
38
MANIFEST.in
|
|
@ -4,23 +4,23 @@ include *.json
|
|||
include *.md
|
||||
include *.py
|
||||
include *.txt
|
||||
recursive-include webnotes *.css
|
||||
recursive-include webnotes *.dat
|
||||
recursive-include webnotes *.eot
|
||||
recursive-include webnotes *.gif
|
||||
recursive-include webnotes *.html
|
||||
recursive-include webnotes *.jpg
|
||||
recursive-include webnotes *.js
|
||||
recursive-include webnotes *.json
|
||||
recursive-include webnotes *.md
|
||||
recursive-include webnotes *.otf
|
||||
recursive-include webnotes *.png
|
||||
recursive-include webnotes *.py
|
||||
recursive-include webnotes *.sql
|
||||
recursive-include webnotes *.svg
|
||||
recursive-include webnotes *.swf
|
||||
recursive-include webnotes *.ttf
|
||||
recursive-include webnotes *.woff
|
||||
recursive-include webnotes *.xml
|
||||
recursive-include webnotes *.txt
|
||||
recursive-include frappe *.css
|
||||
recursive-include frappe *.dat
|
||||
recursive-include frappe *.eot
|
||||
recursive-include frappe *.gif
|
||||
recursive-include frappe *.html
|
||||
recursive-include frappe *.jpg
|
||||
recursive-include frappe *.js
|
||||
recursive-include frappe *.json
|
||||
recursive-include frappe *.md
|
||||
recursive-include frappe *.otf
|
||||
recursive-include frappe *.png
|
||||
recursive-include frappe *.py
|
||||
recursive-include frappe *.sql
|
||||
recursive-include frappe *.svg
|
||||
recursive-include frappe *.swf
|
||||
recursive-include frappe *.ttf
|
||||
recursive-include frappe *.woff
|
||||
recursive-include frappe *.xml
|
||||
recursive-include frappe *.txt
|
||||
recursive-exclude * *.pyc
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
|
||||
# MIT License. See license.txt
|
||||
"""
|
||||
globals attached to webnotes module
|
||||
globals attached to frappe module
|
||||
+ some utility functions that should probably be moved
|
||||
"""
|
||||
|
||||
|
|
@ -15,7 +15,7 @@ import os, sys, importlib, inspect
|
|||
import json
|
||||
import semantic_version
|
||||
|
||||
from webnotes.core.doctype.print_format.print_format import get_html as get_print_html
|
||||
from frappe.core.doctype.print_format.print_format import get_html as get_print_html
|
||||
|
||||
local = Local()
|
||||
|
||||
|
|
@ -47,17 +47,17 @@ def _(msg):
|
|||
if local.lang == "en":
|
||||
return msg
|
||||
|
||||
from webnotes.translate import get_full_dict
|
||||
from frappe.translate import get_full_dict
|
||||
return get_full_dict(local.lang).get(msg, msg)
|
||||
|
||||
def get_lang_dict(fortype, name=None):
|
||||
if local.lang=="en":
|
||||
return {}
|
||||
from webnotes.translate import get_dict
|
||||
from frappe.translate import get_dict
|
||||
return get_dict(fortype, name)
|
||||
|
||||
def set_user_lang(user, user_language=None):
|
||||
from webnotes.translate import get_lang_dict
|
||||
from frappe.translate import get_lang_dict
|
||||
|
||||
if not user_language:
|
||||
user_language = conn.get_value("Profile", user, "language")
|
||||
|
|
@ -140,7 +140,7 @@ _memc = None
|
|||
def cache():
|
||||
global _memc
|
||||
if not _memc:
|
||||
from webnotes.memc import MClient
|
||||
from frappe.memc import MClient
|
||||
_memc = MClient(['localhost:11211'])
|
||||
return _memc
|
||||
|
||||
|
|
@ -220,9 +220,9 @@ def connect(site=None, db_name=None):
|
|||
set_user("Administrator")
|
||||
|
||||
def set_user(username):
|
||||
import webnotes.profile
|
||||
import frappe.profile
|
||||
local.session["user"] = username
|
||||
local.user = webnotes.profile.Profile(username)
|
||||
local.user = frappe.profile.Profile(username)
|
||||
local.restrictions = None
|
||||
local.user_perms = {}
|
||||
|
||||
|
|
@ -230,11 +230,11 @@ def get_request_header(key, default=None):
|
|||
return request.headers.get(key, default)
|
||||
|
||||
def sendmail(recipients=[], sender="", subject="No Subject", message="No Message", as_markdown=False):
|
||||
import webnotes.utils.email_lib
|
||||
import frappe.utils.email_lib
|
||||
if as_markdown:
|
||||
webnotes.utils.email_lib.sendmail_md(recipients, sender=sender, subject=subject, msg=message)
|
||||
frappe.utils.email_lib.sendmail_md(recipients, sender=sender, subject=subject, msg=message)
|
||||
else:
|
||||
webnotes.utils.email_lib.sendmail(recipients, sender=sender, subject=subject, msg=message)
|
||||
frappe.utils.email_lib.sendmail(recipients, sender=sender, subject=subject, msg=message)
|
||||
|
||||
logger = None
|
||||
whitelisted = []
|
||||
|
|
@ -269,31 +269,31 @@ def only_for(roles):
|
|||
|
||||
def clear_cache(user=None, doctype=None):
|
||||
"""clear cache"""
|
||||
import webnotes.sessions
|
||||
import frappe.sessions
|
||||
if doctype:
|
||||
import webnotes.model.doctype
|
||||
webnotes.model.doctype.clear_cache(doctype)
|
||||
import frappe.model.doctype
|
||||
frappe.model.doctype.clear_cache(doctype)
|
||||
reset_metadata_version()
|
||||
elif user:
|
||||
webnotes.sessions.clear_cache(user)
|
||||
frappe.sessions.clear_cache(user)
|
||||
else: # everything
|
||||
import translate
|
||||
webnotes.sessions.clear_cache()
|
||||
frappe.sessions.clear_cache()
|
||||
translate.clear_cache()
|
||||
reset_metadata_version()
|
||||
|
||||
def get_roles(username=None):
|
||||
import webnotes.profile
|
||||
import frappe.profile
|
||||
if not local.session:
|
||||
return ["Guest"]
|
||||
elif not username or username==local.session.user:
|
||||
return local.user.get_roles()
|
||||
else:
|
||||
return webnotes.profile.Profile(username).get_roles()
|
||||
return frappe.profile.Profile(username).get_roles()
|
||||
|
||||
def has_permission(doctype, ptype="read", refdoc=None):
|
||||
import webnotes.permissions
|
||||
return webnotes.permissions.has_permission(doctype, ptype, refdoc)
|
||||
import frappe.permissions
|
||||
return frappe.permissions.has_permission(doctype, ptype, refdoc)
|
||||
|
||||
def clear_perms(doctype):
|
||||
conn.sql("""delete from tabDocPerm where parent=%s""", doctype)
|
||||
|
|
@ -314,70 +314,70 @@ def reset_metadata_version():
|
|||
return v
|
||||
|
||||
def get_obj(dt = None, dn = None, doc=None, doclist=None, with_children = True):
|
||||
from webnotes.model.code import get_obj
|
||||
from frappe.model.code import get_obj
|
||||
return get_obj(dt, dn, doc, doclist, with_children)
|
||||
|
||||
def doc(doctype=None, name=None, fielddata=None):
|
||||
from webnotes.model.doc import Document
|
||||
from frappe.model.doc import Document
|
||||
return Document(doctype, name, fielddata)
|
||||
|
||||
def new_doc(doctype, parent_doc=None, parentfield=None):
|
||||
from webnotes.model.create_new import get_new_doc
|
||||
from frappe.model.create_new import get_new_doc
|
||||
return get_new_doc(doctype, parent_doc, parentfield)
|
||||
|
||||
def new_bean(doctype):
|
||||
from webnotes.model.create_new import get_new_doc
|
||||
from frappe.model.create_new import get_new_doc
|
||||
return bean([get_new_doc(doctype)])
|
||||
|
||||
def doclist(lst=None):
|
||||
from webnotes.model.doclist import DocList
|
||||
from frappe.model.doclist import DocList
|
||||
return DocList(lst)
|
||||
|
||||
def bean(doctype=None, name=None, copy=None):
|
||||
"""return an instance of the object, wrapped as a Bean (webnotes.model.bean)"""
|
||||
from webnotes.model.bean import Bean
|
||||
"""return an instance of the object, wrapped as a Bean (frappe.model.bean)"""
|
||||
from frappe.model.bean import Bean
|
||||
if copy:
|
||||
return Bean(copy_doclist(copy))
|
||||
else:
|
||||
return Bean(doctype, name)
|
||||
|
||||
def set_value(doctype, docname, fieldname, value):
|
||||
import webnotes.client
|
||||
return webnotes.client.set_value(doctype, docname, fieldname, value)
|
||||
import frappe.client
|
||||
return frappe.client.set_value(doctype, docname, fieldname, value)
|
||||
|
||||
def get_doclist(doctype, name=None):
|
||||
return bean(doctype, name).doclist
|
||||
|
||||
def get_doctype(doctype, processed=False):
|
||||
import webnotes.model.doctype
|
||||
return webnotes.model.doctype.get(doctype, processed)
|
||||
import frappe.model.doctype
|
||||
return frappe.model.doctype.get(doctype, processed)
|
||||
|
||||
def delete_doc(doctype=None, name=None, doclist = None, force=0, ignore_doctypes=None,
|
||||
for_reload=False, ignore_permissions=False):
|
||||
import webnotes.model.delete_doc
|
||||
import frappe.model.delete_doc
|
||||
|
||||
if not ignore_doctypes:
|
||||
ignore_doctypes = []
|
||||
|
||||
if isinstance(name, list):
|
||||
for n in name:
|
||||
webnotes.model.delete_doc.delete_doc(doctype, n, doclist, force, ignore_doctypes,
|
||||
frappe.model.delete_doc.delete_doc(doctype, n, doclist, force, ignore_doctypes,
|
||||
for_reload, ignore_permissions)
|
||||
else:
|
||||
webnotes.model.delete_doc.delete_doc(doctype, name, doclist, force, ignore_doctypes,
|
||||
frappe.model.delete_doc.delete_doc(doctype, name, doclist, force, ignore_doctypes,
|
||||
for_reload, ignore_permissions)
|
||||
|
||||
def reload_doc(module, dt=None, dn=None, force=False):
|
||||
import webnotes.modules
|
||||
return webnotes.modules.reload_doc(module, dt, dn, force=force)
|
||||
import frappe.modules
|
||||
return frappe.modules.reload_doc(module, dt, dn, force=force)
|
||||
|
||||
def rename_doc(doctype, old, new, debug=0, force=False, merge=False, ignore_permissions=False):
|
||||
from webnotes.model.rename_doc import rename_doc
|
||||
from frappe.model.rename_doc import rename_doc
|
||||
return rename_doc(doctype, old, new, force=force, merge=merge, ignore_permissions=ignore_permissions)
|
||||
|
||||
def insert(doclist):
|
||||
import webnotes.model
|
||||
return webnotes.model.insert(doclist)
|
||||
import frappe.model
|
||||
return frappe.model.insert(doclist)
|
||||
|
||||
def get_module(modulename):
|
||||
return importlib.import_module(modulename)
|
||||
|
|
@ -399,11 +399,11 @@ def get_pymodule_path(modulename, *joins):
|
|||
def get_module_list(app_name):
|
||||
return get_file_items(os.path.join(os.path.dirname(get_module(app_name).__file__), "modules.txt"))
|
||||
|
||||
def get_all_apps(with_webnotes=False):
|
||||
def get_all_apps(with_frappe=False):
|
||||
apps = get_file_items(os.path.join(local.sites_path, "apps.txt")) \
|
||||
+ get_file_items(os.path.join(local.site_path, "apps.txt"))
|
||||
if with_webnotes:
|
||||
apps.insert(0, 'webnotes')
|
||||
if with_frappe:
|
||||
apps.insert(0, 'frappe')
|
||||
return apps
|
||||
|
||||
def get_installed_apps():
|
||||
|
|
@ -532,8 +532,8 @@ def copy_doclist(in_doclist):
|
|||
return doclist(new_doclist)
|
||||
|
||||
def compare(val1, condition, val2):
|
||||
import webnotes.utils
|
||||
return webnotes.utils.compare(val1, condition, val2)
|
||||
import frappe.utils
|
||||
return frappe.utils.compare(val1, condition, val2)
|
||||
|
||||
def repsond_as_web_page(title, html):
|
||||
local.message_title = title
|
||||
|
|
@ -544,29 +544,29 @@ def repsond_as_web_page(title, html):
|
|||
return obj
|
||||
|
||||
def build_match_conditions(doctype, fields=None, as_condition=True):
|
||||
import webnotes.widgets.reportview
|
||||
return webnotes.widgets.reportview.build_match_conditions(doctype, fields, as_condition)
|
||||
import frappe.widgets.reportview
|
||||
return frappe.widgets.reportview.build_match_conditions(doctype, fields, as_condition)
|
||||
|
||||
def get_list(doctype, filters=None, fields=None, docstatus=None,
|
||||
group_by=None, order_by=None, limit_start=0, limit_page_length=None,
|
||||
as_list=False, debug=False):
|
||||
import webnotes.widgets.reportview
|
||||
return webnotes.widgets.reportview.execute(doctype, filters=filters, fields=fields, docstatus=docstatus,
|
||||
import frappe.widgets.reportview
|
||||
return frappe.widgets.reportview.execute(doctype, filters=filters, fields=fields, docstatus=docstatus,
|
||||
group_by=group_by, order_by=order_by, limit_start=limit_start, limit_page_length=limit_page_length,
|
||||
as_list=as_list, debug=debug)
|
||||
|
||||
def get_jenv():
|
||||
if not local.jenv:
|
||||
from jinja2 import Environment, DebugUndefined
|
||||
import webnotes.utils
|
||||
import frappe.utils
|
||||
|
||||
# webnotes will be loaded last, so app templates will get precedence
|
||||
# frappe will be loaded last, so app templates will get precedence
|
||||
jenv = Environment(loader = get_jloader(), undefined=DebugUndefined)
|
||||
set_filters(jenv)
|
||||
|
||||
jenv.globals.update({
|
||||
"webnotes": sys.modules[__name__],
|
||||
"webnotes.utils": webnotes.utils,
|
||||
"frappe": sys.modules[__name__],
|
||||
"frappe.utils": frappe.utils,
|
||||
"_": _
|
||||
})
|
||||
|
||||
|
|
@ -579,16 +579,16 @@ def get_jloader():
|
|||
from jinja2 import ChoiceLoader, PackageLoader
|
||||
|
||||
apps = get_installed_apps()
|
||||
apps.remove("webnotes")
|
||||
apps.remove("frappe")
|
||||
|
||||
local.jloader = ChoiceLoader([PackageLoader(app, ".") \
|
||||
for app in apps + ["webnotes"]])
|
||||
for app in apps + ["frappe"]])
|
||||
|
||||
return local.jloader
|
||||
|
||||
def set_filters(jenv):
|
||||
from webnotes.utils import global_date_format
|
||||
from webnotes.website.utils import get_hex_shade
|
||||
from frappe.utils import global_date_format
|
||||
from frappe.website.utils import get_hex_shade
|
||||
from markdown2 import markdown
|
||||
from json import dumps
|
||||
|
||||
97
frappe/api.py
Normal file
97
frappe/api.py
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
|
||||
# MIT License. See license.txt
|
||||
|
||||
import frappe
|
||||
import frappe.handler
|
||||
import frappe.client
|
||||
import frappe.widgets.reportview
|
||||
from frappe.utils.response import build_response, report_error
|
||||
|
||||
def handle():
|
||||
"""
|
||||
/api/method/{methodname} will call a whitelisted method
|
||||
/api/resource/{doctype} will query a table
|
||||
examples:
|
||||
?fields=["name", "owner"]
|
||||
?filters=[["Task", "name", "like", "%005"]]
|
||||
?limit_start=0
|
||||
?limit_page_length=20
|
||||
/api/resource/{doctype}/{name} will point to a resource
|
||||
GET will return doclist
|
||||
POST will insert
|
||||
PUT will update
|
||||
DELETE will delete
|
||||
/api/resource/{doctype}/{name}?run_method={method} will run a whitelisted controller method
|
||||
"""
|
||||
parts = frappe.request.path[1:].split("/")
|
||||
call = doctype = name = None
|
||||
|
||||
if len(parts) > 1:
|
||||
call = parts[1]
|
||||
|
||||
if len(parts) > 2:
|
||||
doctype = parts[2]
|
||||
|
||||
if len(parts) > 3:
|
||||
name = parts[3]
|
||||
|
||||
try:
|
||||
if call=="method":
|
||||
frappe.local.form_dict.cmd = doctype
|
||||
frappe.handler.handle()
|
||||
return
|
||||
|
||||
elif call=="resource":
|
||||
if "run_method" in frappe.local.form_dict:
|
||||
bean = frappe.bean(doctype, name)
|
||||
|
||||
if frappe.local.request.method=="GET":
|
||||
if not bean.has_permission("read"):
|
||||
frappe.throw("No Permission", frappe.PermissionError)
|
||||
bean.run_method(frappe.local.form_dict.run_method, **frappe.local.form_dict)
|
||||
|
||||
if frappe.local.request.method=="POST":
|
||||
if not bean.has_permission("write"):
|
||||
frappe.throw("No Permission", frappe.PermissionError)
|
||||
bean.run_method(frappe.local.form_dict.run_method, **frappe.local.form_dict)
|
||||
frappe.conn.commit()
|
||||
|
||||
else:
|
||||
if name:
|
||||
if frappe.local.request.method=="GET":
|
||||
frappe.local.response.update({
|
||||
"doclist": frappe.client.get(doctype,
|
||||
name)})
|
||||
|
||||
if frappe.local.request.method=="POST":
|
||||
frappe.local.response.update({
|
||||
"doclist": frappe.client.insert(frappe.local.form_dict.doclist)})
|
||||
frappe.conn.commit()
|
||||
|
||||
if frappe.local.request.method=="PUT":
|
||||
frappe.local.response.update({
|
||||
"doclist":frappe.client.save(frappe.local.form_dict.doclist)})
|
||||
frappe.conn.commit()
|
||||
|
||||
if frappe.local.request.method=="DELETE":
|
||||
frappe.client.delete(doctype, name)
|
||||
frappe.local.response.message = "ok"
|
||||
|
||||
elif doctype:
|
||||
if frappe.local.request.method=="GET":
|
||||
frappe.local.response.update({
|
||||
"data": frappe.call(frappe.widgets.reportview.execute,
|
||||
doctype, **frappe.local.form_dict)})
|
||||
|
||||
else:
|
||||
raise frappe.DoesNotExistError
|
||||
|
||||
else:
|
||||
raise frappe.DoesNotExistError
|
||||
|
||||
except frappe.DoesNotExistError, e:
|
||||
report_error(404)
|
||||
except Exception, e:
|
||||
report_error(500)
|
||||
|
||||
build_response()
|
||||
|
|
@ -11,14 +11,14 @@ from werkzeug.exceptions import HTTPException, NotFound
|
|||
from werkzeug.contrib.profiler import ProfilerMiddleware
|
||||
|
||||
import mimetypes
|
||||
import webnotes
|
||||
import webnotes.handler
|
||||
import webnotes.auth
|
||||
import webnotes.api
|
||||
import webnotes.website.render
|
||||
from webnotes.utils import get_site_name
|
||||
import frappe
|
||||
import frappe.handler
|
||||
import frappe.auth
|
||||
import frappe.api
|
||||
import frappe.website.render
|
||||
from frappe.utils import get_site_name
|
||||
|
||||
local_manager = LocalManager([webnotes.local])
|
||||
local_manager = LocalManager([frappe.local])
|
||||
|
||||
_site = None
|
||||
|
||||
|
|
@ -37,45 +37,45 @@ def handle_session_stopped():
|
|||
|
||||
@Request.application
|
||||
def application(request):
|
||||
webnotes.local.request = request
|
||||
frappe.local.request = request
|
||||
|
||||
try:
|
||||
site = _site or get_site_name(request.host)
|
||||
webnotes.init(site=site)
|
||||
frappe.init(site=site)
|
||||
|
||||
if not webnotes.local.conf:
|
||||
if not frappe.local.conf:
|
||||
# site does not exist
|
||||
raise NotFound
|
||||
|
||||
webnotes.local.form_dict = webnotes._dict({ k:v[0] if isinstance(v, (list, tuple)) else v \
|
||||
frappe.local.form_dict = frappe._dict({ k:v[0] if isinstance(v, (list, tuple)) else v \
|
||||
for k, v in (request.form or request.args).iteritems() })
|
||||
|
||||
webnotes.local._response = Response()
|
||||
webnotes.http_request = webnotes.auth.HTTPRequest()
|
||||
frappe.local._response = Response()
|
||||
frappe.http_request = frappe.auth.HTTPRequest()
|
||||
|
||||
if webnotes.local.form_dict.cmd:
|
||||
webnotes.handler.handle()
|
||||
elif webnotes.request.path.startswith("/api/"):
|
||||
webnotes.api.handle()
|
||||
elif webnotes.local.request.method in ('GET', 'HEAD'):
|
||||
webnotes.website.render.render(webnotes.request.path[1:])
|
||||
if frappe.local.form_dict.cmd:
|
||||
frappe.handler.handle()
|
||||
elif frappe.request.path.startswith("/api/"):
|
||||
frappe.api.handle()
|
||||
elif frappe.local.request.method in ('GET', 'HEAD'):
|
||||
frappe.website.render.render(frappe.request.path[1:])
|
||||
else:
|
||||
raise NotFound
|
||||
|
||||
except HTTPException, e:
|
||||
return e
|
||||
|
||||
except webnotes.AuthenticationError, e:
|
||||
webnotes._response.status_code=401
|
||||
except frappe.AuthenticationError, e:
|
||||
frappe._response.status_code=401
|
||||
|
||||
except webnotes.SessionStopped, e:
|
||||
webnotes.local._response = handle_session_stopped()
|
||||
except frappe.SessionStopped, e:
|
||||
frappe.local._response = handle_session_stopped()
|
||||
|
||||
finally:
|
||||
if webnotes.conn:
|
||||
webnotes.conn.close()
|
||||
if frappe.conn:
|
||||
frappe.conn.close()
|
||||
|
||||
return webnotes.local._response
|
||||
return frappe.local._response
|
||||
|
||||
application = local_manager.make_middleware(application)
|
||||
|
||||
262
frappe/auth.py
Normal file
262
frappe/auth.py
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
|
||||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import frappe
|
||||
import frappe.db
|
||||
import frappe.utils
|
||||
import frappe.profile
|
||||
from frappe import conf
|
||||
from frappe.sessions import Session
|
||||
|
||||
|
||||
class HTTPRequest:
|
||||
def __init__(self):
|
||||
# Get Environment variables
|
||||
self.domain = frappe.request.host
|
||||
if self.domain and self.domain.startswith('www.'):
|
||||
self.domain = self.domain[4:]
|
||||
|
||||
# language
|
||||
self.set_lang(frappe.get_request_header('HTTP_ACCEPT_LANGUAGE'))
|
||||
|
||||
# load cookies
|
||||
frappe.local.cookie_manager = CookieManager()
|
||||
|
||||
# override request method. All request to be of type POST, but if _type == "POST" then commit
|
||||
if frappe.form_dict.get("_type"):
|
||||
frappe.local.request_method = frappe.form_dict.get("_type")
|
||||
del frappe.form_dict["_type"]
|
||||
|
||||
# set db
|
||||
self.connect()
|
||||
|
||||
# login
|
||||
frappe.local.login_manager = LoginManager()
|
||||
|
||||
# check status
|
||||
if frappe.conn.get_global("__session_status")=='stop':
|
||||
frappe.msgprint(frappe.conn.get_global("__session_status_message"))
|
||||
raise frappe.SessionStopped('Session Stopped')
|
||||
|
||||
# load profile
|
||||
self.setup_profile()
|
||||
|
||||
# run login triggers
|
||||
if frappe.form_dict.get('cmd')=='login':
|
||||
frappe.local.login_manager.run_trigger('on_session_creation')
|
||||
|
||||
def set_lang(self, lang):
|
||||
import translate
|
||||
lang_list = translate.get_all_languages() or []
|
||||
|
||||
if not lang:
|
||||
return
|
||||
if ";" in lang: # not considering weightage
|
||||
lang = lang.split(";")[0]
|
||||
if "," in lang:
|
||||
lang = lang.split(",")
|
||||
else:
|
||||
lang = [lang]
|
||||
|
||||
for l in lang:
|
||||
code = l.strip()
|
||||
if code in lang_list:
|
||||
frappe.local.lang = code
|
||||
return
|
||||
|
||||
# check if parent language (pt) is setup, if variant (pt-BR)
|
||||
if "-" in code:
|
||||
code = code.split("-")[0]
|
||||
if code in lang_list:
|
||||
frappe.local.lang = code
|
||||
return
|
||||
|
||||
def setup_profile(self):
|
||||
frappe.local.user = frappe.profile.Profile()
|
||||
|
||||
def get_db_name(self):
|
||||
"""get database name from conf"""
|
||||
return conf.db_name
|
||||
|
||||
def connect(self, ac_name = None):
|
||||
"""connect to db, from ac_name or db_name"""
|
||||
frappe.local.conn = frappe.db.Database(user = self.get_db_name(), \
|
||||
password = getattr(conf,'db_password', ''))
|
||||
|
||||
class LoginManager:
|
||||
def __init__(self):
|
||||
self.user = None
|
||||
if frappe.local.form_dict.get('cmd')=='login' or frappe.local.request.path=="/api/method/login":
|
||||
self.login()
|
||||
else:
|
||||
self.make_session(resume=True)
|
||||
|
||||
def login(self):
|
||||
# clear cache
|
||||
frappe.clear_cache(user = frappe.form_dict.get('usr'))
|
||||
self.authenticate()
|
||||
self.post_login()
|
||||
|
||||
def post_login(self):
|
||||
self.run_trigger('on_login')
|
||||
self.validate_ip_address()
|
||||
self.validate_hour()
|
||||
self.make_session()
|
||||
self.set_user_info()
|
||||
|
||||
def set_user_info(self):
|
||||
info = frappe.conn.get_value("Profile", self.user,
|
||||
["user_type", "first_name", "last_name", "user_image"], as_dict=1)
|
||||
if info.user_type=="Website User":
|
||||
frappe.local._response.set_cookie("system_user", "no")
|
||||
frappe.local.response["message"] = "No App"
|
||||
else:
|
||||
frappe.local._response.set_cookie("system_user", "yes")
|
||||
frappe.local.response['message'] = 'Logged In'
|
||||
|
||||
full_name = " ".join(filter(None, [info.first_name, info.last_name]))
|
||||
frappe.response["full_name"] = full_name
|
||||
frappe._response.set_cookie("full_name", full_name)
|
||||
frappe._response.set_cookie("user_id", self.user)
|
||||
frappe._response.set_cookie("user_image", info.user_image or "")
|
||||
|
||||
def make_session(self, resume=False):
|
||||
# start session
|
||||
frappe.local.session_obj = Session(user=self.user, resume=resume)
|
||||
|
||||
# reset user if changed to Guest
|
||||
self.user = frappe.local.session_obj.user
|
||||
frappe.local.session = frappe.local.session_obj.data
|
||||
|
||||
def authenticate(self, user=None, pwd=None):
|
||||
if not (user and pwd):
|
||||
user, pwd = frappe.form_dict.get('usr'), frappe.form_dict.get('pwd')
|
||||
if not (user and pwd):
|
||||
self.fail('Incomplete login details')
|
||||
|
||||
self.check_if_enabled(user)
|
||||
self.user = self.check_password(user, pwd)
|
||||
|
||||
def check_if_enabled(self, user):
|
||||
"""raise exception if user not enabled"""
|
||||
from frappe.utils import cint
|
||||
if user=='Administrator': return
|
||||
if not cint(frappe.conn.get_value('Profile', user, 'enabled')):
|
||||
self.fail('User disabled or missing')
|
||||
|
||||
def check_password(self, user, pwd):
|
||||
"""check password"""
|
||||
user = frappe.conn.sql("""select `user` from __Auth where `user`=%s
|
||||
and `password`=password(%s)""", (user, pwd))
|
||||
if not user:
|
||||
self.fail('Incorrect password')
|
||||
else:
|
||||
return user[0][0] # in correct case
|
||||
|
||||
def fail(self, message):
|
||||
frappe.local.response['message'] = message
|
||||
raise frappe.AuthenticationError
|
||||
|
||||
|
||||
def run_trigger(self, method='on_login'):
|
||||
for method in frappe.get_hooks().get("method", []):
|
||||
frappe.get_attr(method)(self)
|
||||
|
||||
def validate_ip_address(self):
|
||||
"""check if IP Address is valid"""
|
||||
ip_list = frappe.conn.get_value('Profile', self.user, 'restrict_ip', ignore=True)
|
||||
|
||||
if not ip_list:
|
||||
return
|
||||
|
||||
ip_list = ip_list.replace(",", "\n").split('\n')
|
||||
ip_list = [i.strip() for i in ip_list]
|
||||
|
||||
for ip in ip_list:
|
||||
if frappe.get_request_header('REMOTE_ADDR', '').startswith(ip) or frappe.get_request_header('X-Forwarded-For', '').startswith(ip):
|
||||
return
|
||||
|
||||
frappe.msgprint('Not allowed from this IP Address')
|
||||
raise frappe.AuthenticationError
|
||||
|
||||
def validate_hour(self):
|
||||
"""check if user is logging in during restricted hours"""
|
||||
login_before = int(frappe.conn.get_value('Profile', self.user, 'login_before', ignore=True) or 0)
|
||||
login_after = int(frappe.conn.get_value('Profile', self.user, 'login_after', ignore=True) or 0)
|
||||
|
||||
if not (login_before or login_after):
|
||||
return
|
||||
|
||||
from frappe.utils import now_datetime
|
||||
current_hour = int(now_datetime().strftime('%H'))
|
||||
|
||||
if login_before and current_hour > login_before:
|
||||
frappe.msgprint('Not allowed to login after restricted hour', raise_exception=1)
|
||||
|
||||
if login_after and current_hour < login_after:
|
||||
frappe.msgprint('Not allowed to login before restricted hour', raise_exception=1)
|
||||
|
||||
def login_as_guest(self):
|
||||
"""login as guest"""
|
||||
self.user = 'Guest'
|
||||
self.post_login()
|
||||
|
||||
def logout(self, arg='', user=None):
|
||||
if not user: user = frappe.session.user
|
||||
self.run_trigger('on_logout')
|
||||
if user in ['demo@erpnext.com', 'Administrator']:
|
||||
frappe.conn.sql('delete from tabSessions where sid=%s', frappe.session.get('sid'))
|
||||
frappe.cache().delete_value("session:" + frappe.session.get("sid"))
|
||||
else:
|
||||
from frappe.sessions import clear_sessions
|
||||
clear_sessions(user)
|
||||
|
||||
if user == frappe.session.user:
|
||||
frappe.session.sid = ""
|
||||
frappe.local._response.delete_cookie("full_name")
|
||||
frappe.local._response.delete_cookie("user_id")
|
||||
frappe.local._response.delete_cookie("sid")
|
||||
frappe.local._response.set_cookie("full_name", "")
|
||||
frappe.local._response.set_cookie("user_id", "")
|
||||
frappe.local._response.set_cookie("sid", "")
|
||||
|
||||
class CookieManager:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def set_cookies(self):
|
||||
if not frappe.local.session.get('sid'): return
|
||||
import datetime
|
||||
|
||||
# sid expires in 3 days
|
||||
expires = datetime.datetime.now() + datetime.timedelta(days=3)
|
||||
if frappe.session.sid:
|
||||
frappe.local._response.set_cookie("sid", frappe.session.sid, expires = expires)
|
||||
if frappe.session.session_country:
|
||||
frappe.local._response.set_cookie('country', frappe.session.get("session_country"))
|
||||
|
||||
def set_remember_me(self):
|
||||
from frappe.utils import cint
|
||||
|
||||
if not cint(frappe.form_dict.get('remember_me')): return
|
||||
|
||||
remember_days = frappe.conn.get_value('Control Panel', None,
|
||||
'remember_for_days') or 7
|
||||
|
||||
import datetime
|
||||
expires = datetime.datetime.now() + \
|
||||
datetime.timedelta(days=remember_days)
|
||||
|
||||
frappe.local._response.set_cookie["remember_me"] = 1
|
||||
|
||||
|
||||
def _update_password(user, password):
|
||||
frappe.conn.sql("""insert into __Auth (user, `password`)
|
||||
values (%s, password(%s))
|
||||
on duplicate key update `password`=password(%s)""", (user,
|
||||
password, password))
|
||||
|
||||
@frappe.whitelist()
|
||||
def get_logged_user():
|
||||
return frappe.session.user
|
||||
139
frappe/boot.py
Normal file
139
frappe/boot.py
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
|
||||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
"""
|
||||
bootstrap client session
|
||||
"""
|
||||
|
||||
import frappe
|
||||
import frappe.defaults
|
||||
import frappe.model.doc
|
||||
import frappe.widgets.page
|
||||
import json
|
||||
|
||||
def get_bootinfo():
|
||||
"""build and return boot info"""
|
||||
bootinfo = frappe._dict()
|
||||
hooks = frappe.get_hooks()
|
||||
doclist = []
|
||||
|
||||
# profile
|
||||
get_profile(bootinfo)
|
||||
|
||||
# control panel
|
||||
cp = frappe.model.doc.getsingle('Control Panel')
|
||||
|
||||
# system info
|
||||
bootinfo['control_panel'] = frappe._dict(cp.copy())
|
||||
bootinfo['sysdefaults'] = frappe.defaults.get_defaults()
|
||||
bootinfo['server_date'] = frappe.utils.nowdate()
|
||||
bootinfo["send_print_in_body_and_attachment"] = frappe.conn.get_value("Email Settings",
|
||||
None, "send_print_in_body_and_attachment")
|
||||
|
||||
if frappe.session['user'] != 'Guest':
|
||||
bootinfo['user_info'] = get_fullnames()
|
||||
bootinfo['sid'] = frappe.session['sid'];
|
||||
|
||||
# home page
|
||||
bootinfo.modules = {}
|
||||
for app in frappe.get_installed_apps():
|
||||
try:
|
||||
bootinfo.modules.update(frappe.get_attr(app + ".config.desktop.data") or {})
|
||||
except ImportError, e:
|
||||
pass
|
||||
|
||||
bootinfo.hidden_modules = frappe.conn.get_global("hidden_modules")
|
||||
bootinfo.doctype_icons = dict(frappe.conn.sql("""select name, icon from
|
||||
tabDocType where ifnull(icon,'')!=''"""))
|
||||
bootinfo.doctype_icons.update(dict(frappe.conn.sql("""select name, icon from
|
||||
tabPage where ifnull(icon,'')!=''""")))
|
||||
|
||||
add_home_page(bootinfo, doclist)
|
||||
add_allowed_pages(bootinfo)
|
||||
load_translations(bootinfo)
|
||||
load_conf_settings(bootinfo)
|
||||
load_startup_js(bootinfo)
|
||||
|
||||
# ipinfo
|
||||
if frappe.session['data'].get('ipinfo'):
|
||||
bootinfo['ipinfo'] = frappe.session['data']['ipinfo']
|
||||
|
||||
# add docs
|
||||
bootinfo['docs'] = doclist
|
||||
|
||||
for method in hooks.boot_session or []:
|
||||
frappe.get_attr(method)(bootinfo)
|
||||
|
||||
from frappe.model.utils import compress
|
||||
bootinfo['docs'] = compress(bootinfo['docs'])
|
||||
|
||||
if bootinfo.lang:
|
||||
bootinfo.lang = unicode(bootinfo.lang)
|
||||
|
||||
bootinfo.metadata_version = frappe.cache().get_value("metadata_version")
|
||||
if not bootinfo.metadata_version:
|
||||
bootinfo.metadata_version = frappe.reset_metadata_version()
|
||||
|
||||
return bootinfo
|
||||
|
||||
def load_conf_settings(bootinfo):
|
||||
from frappe import conf
|
||||
for key in ['developer_mode']:
|
||||
if key in conf: bootinfo[key] = conf.get(key)
|
||||
|
||||
def add_allowed_pages(bootinfo):
|
||||
bootinfo.page_info = dict(frappe.conn.sql("""select distinct parent, modified from `tabPage Role`
|
||||
where role in ('%s')""" % "', '".join(frappe.get_roles())))
|
||||
|
||||
def load_translations(bootinfo):
|
||||
frappe.set_user_lang(frappe.session.user)
|
||||
|
||||
if frappe.lang != 'en':
|
||||
bootinfo["__messages"] = frappe.get_lang_dict("include")
|
||||
bootinfo["lang"] = frappe.lang
|
||||
|
||||
def get_fullnames():
|
||||
"""map of user fullnames"""
|
||||
ret = frappe.conn.sql("""select name,
|
||||
concat(ifnull(first_name, ''),
|
||||
if(ifnull(last_name, '')!='', ' ', ''), ifnull(last_name, '')),
|
||||
user_image, gender, email
|
||||
from tabProfile where ifnull(enabled, 0)=1""", as_list=1)
|
||||
d = {}
|
||||
for r in ret:
|
||||
if not r[2]:
|
||||
r[2] = '/assets/frappe/images/ui/avatar.png'
|
||||
else:
|
||||
r[2] = r[2]
|
||||
|
||||
d[r[0]]= {'fullname': r[1], 'image': r[2], 'gender': r[3],
|
||||
'email': r[4] or r[0]}
|
||||
|
||||
return d
|
||||
|
||||
def load_startup_js(bootinfo):
|
||||
bootinfo.startup_js = ""
|
||||
for method in frappe.get_hooks().startup_js or []:
|
||||
bootinfo.startup_js += frappe.get_attr(method)()
|
||||
|
||||
def get_profile(bootinfo):
|
||||
"""get profile info"""
|
||||
bootinfo['profile'] = frappe.user.load_profile()
|
||||
|
||||
def add_home_page(bootinfo, doclist):
|
||||
"""load home page"""
|
||||
|
||||
if frappe.session.user=="Guest":
|
||||
return
|
||||
|
||||
home_page = frappe.get_application_home_page(frappe.session.user)
|
||||
|
||||
try:
|
||||
page_doclist = frappe.widgets.page.get(home_page)
|
||||
except (frappe.DoesNotExistError, frappe.PermissionError), e:
|
||||
page_doclist = frappe.widgets.page.get('desktop')
|
||||
|
||||
bootinfo['home_page_html'] = page_doclist[0].content
|
||||
bootinfo['home_page'] = page_doclist[0].name
|
||||
doclist += page_doclist
|
||||
|
|
@ -2,22 +2,22 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
from webnotes.utils.minify import JavascriptMinify
|
||||
from frappe.utils.minify import JavascriptMinify
|
||||
|
||||
"""
|
||||
Build the `public` folders and setup languages
|
||||
"""
|
||||
|
||||
import os, sys, webnotes, json, shutil
|
||||
import os, sys, frappe, json, shutil
|
||||
from cssmin import cssmin
|
||||
import webnotes.translate
|
||||
import frappe.translate
|
||||
|
||||
def bundle(no_compress):
|
||||
"""concat / minify js files"""
|
||||
# build js files
|
||||
make_asset_dirs()
|
||||
build(no_compress)
|
||||
webnotes.translate.clear_cache()
|
||||
frappe.translate.clear_cache()
|
||||
|
||||
def watch(no_compress):
|
||||
"""watch and rebuild if necessary"""
|
||||
|
|
@ -31,8 +31,8 @@ def watch(no_compress):
|
|||
time.sleep(3)
|
||||
|
||||
def make_asset_dirs():
|
||||
assets_path = os.path.join(webnotes.local.sites_path, "assets")
|
||||
site_public_path = os.path.join(webnotes.local.site_path, 'public')
|
||||
assets_path = os.path.join(frappe.local.sites_path, "assets")
|
||||
site_public_path = os.path.join(frappe.local.site_path, 'public')
|
||||
for dir_path in [
|
||||
os.path.join(assets_path, 'js'),
|
||||
os.path.join(assets_path, 'css')]:
|
||||
|
|
@ -41,8 +41,8 @@ def make_asset_dirs():
|
|||
os.makedirs(dir_path)
|
||||
|
||||
# symlink app/public > assets/app
|
||||
for app_name in webnotes.get_all_apps(True):
|
||||
pymodule = webnotes.get_module(app_name)
|
||||
for app_name in frappe.get_all_apps(True):
|
||||
pymodule = frappe.get_module(app_name)
|
||||
source = os.path.join(os.path.abspath(os.path.dirname(pymodule.__file__)), 'public')
|
||||
target = os.path.join(assets_path, app_name)
|
||||
|
||||
|
|
@ -50,18 +50,18 @@ def make_asset_dirs():
|
|||
os.symlink(os.path.abspath(source), target)
|
||||
|
||||
def build(no_compress=False):
|
||||
assets_path = os.path.join(webnotes.local.sites_path, "assets")
|
||||
assets_path = os.path.join(frappe.local.sites_path, "assets")
|
||||
|
||||
for target, sources in get_build_maps().iteritems():
|
||||
pack(os.path.join(assets_path, target), sources, no_compress)
|
||||
|
||||
shutil.copy(os.path.join(os.path.dirname(os.path.abspath(webnotes.__file__)), 'data', 'languages.txt'), webnotes.local.sites_path)
|
||||
shutil.copy(os.path.join(os.path.dirname(os.path.abspath(frappe.__file__)), 'data', 'languages.txt'), frappe.local.sites_path)
|
||||
# reset_app_html()
|
||||
|
||||
def get_build_maps():
|
||||
"""get all build.jsons with absolute paths"""
|
||||
# framework js and css files
|
||||
pymodules = [webnotes.get_module(app) for app in webnotes.get_all_apps(True)]
|
||||
pymodules = [frappe.get_module(app) for app in frappe.get_all_apps(True)]
|
||||
app_paths = [os.path.dirname(pymodule.__file__) for pymodule in pymodules]
|
||||
|
||||
build_maps = {}
|
||||
|
|
@ -75,7 +75,7 @@ def get_build_maps():
|
|||
source_paths = []
|
||||
for source in sources:
|
||||
if isinstance(source, list):
|
||||
s = webnotes.get_pymodule_path(source[0], *source[1].split("/"))
|
||||
s = frappe.get_pymodule_path(source[0], *source[1].split("/"))
|
||||
else:
|
||||
s = os.path.join(app_path, source)
|
||||
source_paths.append(s)
|
||||
|
|
@ -114,7 +114,7 @@ def pack(target, sources, no_compress):
|
|||
|
||||
except Exception, e:
|
||||
print "--Error in:" + f + "--"
|
||||
print webnotes.get_traceback()
|
||||
print frappe.get_traceback()
|
||||
|
||||
if not no_compress and outtype == 'css':
|
||||
pass
|
||||
|
|
@ -6,12 +6,12 @@
|
|||
from __future__ import unicode_literals
|
||||
import sys, os
|
||||
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
site_arg_optional = []
|
||||
|
||||
def main():
|
||||
parsed_args = webnotes._dict(vars(setup_parser()))
|
||||
parsed_args = frappe._dict(vars(setup_parser()))
|
||||
fn = get_function(parsed_args)
|
||||
if not parsed_args.get("sites_path"):
|
||||
parsed_args["sites_path"] = "."
|
||||
|
|
@ -22,7 +22,7 @@ def main():
|
|||
for site in get_sites(parsed_args["sites_path"]):
|
||||
args = parsed_args.copy()
|
||||
args["site"] = site
|
||||
webnotes.init(site)
|
||||
frappe.init(site)
|
||||
run(fn, args)
|
||||
else:
|
||||
if not fn in site_arg_optional:
|
||||
|
|
@ -40,7 +40,7 @@ def main():
|
|||
print "Did not find folder '{}'. Are you in sites folder?".format(parsed_args.get("site"))
|
||||
exit(1)
|
||||
|
||||
webnotes.init(site)
|
||||
frappe.init(site)
|
||||
run(fn, parsed_args)
|
||||
else:
|
||||
run(fn, parsed_args)
|
||||
|
|
@ -84,7 +84,7 @@ def get_sites(sites_path=None):
|
|||
|
||||
def setup_parser():
|
||||
import argparse
|
||||
parser = argparse.ArgumentParser(description="Run webnotes utility functions")
|
||||
parser = argparse.ArgumentParser(description="Run frappe utility functions")
|
||||
|
||||
setup_install(parser)
|
||||
setup_utilities(parser)
|
||||
|
|
@ -228,35 +228,35 @@ def setup_translation(parser):
|
|||
# methods
|
||||
@cmd
|
||||
def make_app():
|
||||
from webnotes.utils.boilerplate import make_boilerplate
|
||||
from frappe.utils.boilerplate import make_boilerplate
|
||||
make_boilerplate()
|
||||
|
||||
@cmd
|
||||
def use():
|
||||
with open("currentsite.txt", "w") as sitefile:
|
||||
sitefile.write(webnotes.local.site)
|
||||
sitefile.write(frappe.local.site)
|
||||
|
||||
# install
|
||||
@cmd
|
||||
def install(db_name, root_login="root", root_password=None, source_sql=None,
|
||||
admin_password = 'admin', verbose=True, force=False, site_config=None, reinstall=False):
|
||||
from webnotes.installer import install_db, install_app, make_site_dirs
|
||||
from frappe.installer import install_db, install_app, make_site_dirs
|
||||
install_db(root_login=root_login, root_password=root_password, db_name=db_name, source_sql=source_sql,
|
||||
admin_password = admin_password, verbose=verbose, force=force, site_config=site_config, reinstall=reinstall)
|
||||
make_site_dirs()
|
||||
install_app("webnotes", verbose=verbose)
|
||||
webnotes.destroy()
|
||||
install_app("frappe", verbose=verbose)
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def install_app(app_name, verbose=False):
|
||||
from webnotes.installer import install_app
|
||||
webnotes.connect()
|
||||
from frappe.installer import install_app
|
||||
frappe.connect()
|
||||
install_app(app_name, verbose=verbose)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def reinstall(verbose=True):
|
||||
install(db_name=webnotes.conf.db_name, verbose=verbose, force=True, reinstall=True)
|
||||
install(db_name=frappe.conf.db_name, verbose=verbose, force=True, reinstall=True)
|
||||
|
||||
@cmd
|
||||
def restore(db_name, source_sql, verbose=True, force=False):
|
||||
|
|
@ -264,16 +264,16 @@ def restore(db_name, source_sql, verbose=True, force=False):
|
|||
|
||||
@cmd
|
||||
def install_fixtures():
|
||||
from webnotes.install_lib.install import install_fixtures
|
||||
from frappe.install_lib.install import install_fixtures
|
||||
install_fixtures()
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def add_system_manager(email, first_name=None, last_name=None):
|
||||
webnotes.connect()
|
||||
webnotes.profile.add_system_manager(email, first_name, last_name)
|
||||
webnotes.conn.commit()
|
||||
webnotes.destroy()
|
||||
frappe.connect()
|
||||
frappe.profile.add_system_manager(email, first_name, last_name)
|
||||
frappe.conn.commit()
|
||||
frappe.destroy()
|
||||
|
||||
# utilities
|
||||
|
||||
|
|
@ -282,7 +282,7 @@ def update(remote=None, branch=None, reload_gunicorn=False):
|
|||
pull(remote=remote, branch=branch)
|
||||
|
||||
# maybe there are new framework changes, any consequences?
|
||||
reload(webnotes)
|
||||
reload(frappe)
|
||||
build()
|
||||
latest()
|
||||
if reload_gunicorn:
|
||||
|
|
@ -291,88 +291,88 @@ def update(remote=None, branch=None, reload_gunicorn=False):
|
|||
|
||||
@cmd
|
||||
def latest(verbose=True):
|
||||
import webnotes.modules.patch_handler
|
||||
import webnotes.model.sync
|
||||
from webnotes.website import rebuild_config
|
||||
import frappe.modules.patch_handler
|
||||
import frappe.model.sync
|
||||
from frappe.website import rebuild_config
|
||||
|
||||
webnotes.connect()
|
||||
frappe.connect()
|
||||
|
||||
try:
|
||||
# run patches
|
||||
webnotes.local.patch_log_list = []
|
||||
webnotes.modules.patch_handler.run_all()
|
||||
frappe.local.patch_log_list = []
|
||||
frappe.modules.patch_handler.run_all()
|
||||
if verbose:
|
||||
print "\n".join(webnotes.local.patch_log_list)
|
||||
print "\n".join(frappe.local.patch_log_list)
|
||||
|
||||
# sync
|
||||
webnotes.model.sync.sync_all()
|
||||
frappe.model.sync.sync_all()
|
||||
|
||||
# build website config if any changes in templates etc.
|
||||
rebuild_config()
|
||||
|
||||
except webnotes.modules.patch_handler.PatchError, e:
|
||||
print "\n".join(webnotes.local.patch_log_list)
|
||||
except frappe.modules.patch_handler.PatchError, e:
|
||||
print "\n".join(frappe.local.patch_log_list)
|
||||
raise
|
||||
finally:
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def sync_all(force=False):
|
||||
import webnotes.model.sync
|
||||
webnotes.connect()
|
||||
webnotes.model.sync.sync_all(force=force)
|
||||
webnotes.destroy()
|
||||
import frappe.model.sync
|
||||
frappe.connect()
|
||||
frappe.model.sync.sync_all(force=force)
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def patch(patch_module, force=False):
|
||||
import webnotes.modules.patch_handler
|
||||
webnotes.connect()
|
||||
webnotes.local.patch_log_list = []
|
||||
webnotes.modules.patch_handler.run_single(patch_module, force=force)
|
||||
print "\n".join(webnotes.local.patch_log_list)
|
||||
webnotes.destroy()
|
||||
import frappe.modules.patch_handler
|
||||
frappe.connect()
|
||||
frappe.local.patch_log_list = []
|
||||
frappe.modules.patch_handler.run_single(patch_module, force=force)
|
||||
print "\n".join(frappe.local.patch_log_list)
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def update_all_sites(remote=None, branch=None, verbose=True):
|
||||
pull(remote, branch)
|
||||
|
||||
# maybe there are new framework changes, any consequences?
|
||||
reload(webnotes)
|
||||
reload(frappe)
|
||||
|
||||
build()
|
||||
for site in get_sites():
|
||||
webnotes.init(site)
|
||||
frappe.init(site)
|
||||
latest(verbose=verbose)
|
||||
|
||||
@cmd
|
||||
def reload_doc(module, doctype, docname, force=False):
|
||||
webnotes.connect()
|
||||
webnotes.reload_doc(module, doctype, docname, force=force)
|
||||
webnotes.conn.commit()
|
||||
webnotes.destroy()
|
||||
frappe.connect()
|
||||
frappe.reload_doc(module, doctype, docname, force=force)
|
||||
frappe.conn.commit()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def build():
|
||||
import webnotes.build
|
||||
import webnotes
|
||||
webnotes.build.bundle(False)
|
||||
import frappe.build
|
||||
import frappe
|
||||
frappe.build.bundle(False)
|
||||
|
||||
@cmd
|
||||
def watch():
|
||||
import webnotes.build
|
||||
webnotes.build.watch(True)
|
||||
import frappe.build
|
||||
frappe.build.watch(True)
|
||||
|
||||
@cmd
|
||||
def backup(with_files=False, verbose=True, backup_path_db=None, backup_path_files=None):
|
||||
from webnotes.utils.backups import scheduled_backup
|
||||
webnotes.connect()
|
||||
from frappe.utils.backups import scheduled_backup
|
||||
frappe.connect()
|
||||
odb = scheduled_backup(ignore_files=not with_files, backup_path_db=backup_path_db, backup_path_files=backup_path_files)
|
||||
if verbose:
|
||||
from webnotes.utils import now
|
||||
from frappe.utils import now
|
||||
print "database backup taken -", odb.backup_path_db, "- on", now()
|
||||
if with_files:
|
||||
print "files backup taken -", odb.backup_path_files, "- on", now()
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
return odb
|
||||
|
||||
@cmd
|
||||
|
|
@ -383,7 +383,7 @@ def move(dest_dir=None):
|
|||
if not os.path.isdir(dest_dir):
|
||||
raise Exception, "destination is not a directory or does not exist"
|
||||
|
||||
old_path = webnotes.utils.get_site()
|
||||
old_path = frappe.utils.get_site()
|
||||
new_path = os.path.join(dest_dir, site)
|
||||
|
||||
# check if site dump of same name already exists
|
||||
|
|
@ -395,87 +395,87 @@ def move(dest_dir=None):
|
|||
count = int(count or 0) + 1
|
||||
|
||||
os.rename(old_path, final_new_path)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
return os.path.basename(final_new_path)
|
||||
|
||||
@cmd
|
||||
def domain(host_url=None):
|
||||
webnotes.connect()
|
||||
frappe.connect()
|
||||
if host_url:
|
||||
webnotes.conn.set_value("Website Settings", None, "subdomain", host_url)
|
||||
webnotes.conn.commit()
|
||||
frappe.conn.set_value("Website Settings", None, "subdomain", host_url)
|
||||
frappe.conn.commit()
|
||||
else:
|
||||
print webnotes.conn.get_value("Website Settings", None, "subdomain")
|
||||
webnotes.destroy()
|
||||
print frappe.conn.get_value("Website Settings", None, "subdomain")
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def make_conf(db_name=None, db_password=None, site_config=None):
|
||||
from webnotes.install_lib.install import make_conf
|
||||
from frappe.install_lib.install import make_conf
|
||||
make_conf(db_name=db_name, db_password=db_password, site_config=site_config)
|
||||
|
||||
@cmd
|
||||
def make_custom_server_script(doctype):
|
||||
from webnotes.core.doctype.custom_script.custom_script import make_custom_server_script_file
|
||||
webnotes.connect()
|
||||
from frappe.core.doctype.custom_script.custom_script import make_custom_server_script_file
|
||||
frappe.connect()
|
||||
make_custom_server_script_file(doctype)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
# clear
|
||||
@cmd
|
||||
def clear_cache():
|
||||
import webnotes.sessions
|
||||
webnotes.connect()
|
||||
webnotes.clear_cache()
|
||||
webnotes.destroy()
|
||||
import frappe.sessions
|
||||
frappe.connect()
|
||||
frappe.clear_cache()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def clear_web():
|
||||
import webnotes.website.render
|
||||
webnotes.connect()
|
||||
webnotes.website.render.clear_cache()
|
||||
webnotes.destroy()
|
||||
import frappe.website.render
|
||||
frappe.connect()
|
||||
frappe.website.render.clear_cache()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def build_sitemap():
|
||||
from webnotes.website import rebuild_config
|
||||
webnotes.connect()
|
||||
from frappe.website import rebuild_config
|
||||
frappe.connect()
|
||||
rebuild_config()
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def sync_statics():
|
||||
from webnotes.website.doctype.web_page import web_page
|
||||
webnotes.connect()
|
||||
from frappe.website.doctype.web_page import web_page
|
||||
frappe.connect()
|
||||
web_page.sync_statics()
|
||||
webnotes.conn.commit()
|
||||
webnotes.destroy()
|
||||
frappe.conn.commit()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def reset_perms():
|
||||
webnotes.connect()
|
||||
for d in webnotes.conn.sql_list("""select name from `tabDocType`
|
||||
frappe.connect()
|
||||
for d in frappe.conn.sql_list("""select name from `tabDocType`
|
||||
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
|
||||
webnotes.clear_cache(doctype=d)
|
||||
webnotes.reset_perms(d)
|
||||
webnotes.destroy()
|
||||
frappe.clear_cache(doctype=d)
|
||||
frappe.reset_perms(d)
|
||||
frappe.destroy()
|
||||
|
||||
# scheduler
|
||||
@cmd
|
||||
def run_scheduler():
|
||||
from webnotes.utils.file_lock import create_lock, delete_lock
|
||||
import webnotes.utils.scheduler
|
||||
from frappe.utils.file_lock import create_lock, delete_lock
|
||||
import frappe.utils.scheduler
|
||||
if create_lock('scheduler'):
|
||||
webnotes.connect()
|
||||
print webnotes.utils.scheduler.execute()
|
||||
frappe.connect()
|
||||
print frappe.utils.scheduler.execute()
|
||||
delete_lock('scheduler')
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def run_scheduler_event(event):
|
||||
import webnotes.utils.scheduler
|
||||
webnotes.connect()
|
||||
print webnotes.utils.scheduler.trigger(event)
|
||||
webnotes.destroy()
|
||||
import frappe.utils.scheduler
|
||||
frappe.connect()
|
||||
print frappe.utils.scheduler.trigger(event)
|
||||
frappe.destroy()
|
||||
|
||||
# replace
|
||||
@cmd
|
||||
|
|
@ -486,53 +486,53 @@ def replace(search_regex, replacement, extn, force=False):
|
|||
# import/export
|
||||
@cmd
|
||||
def export_doc(doctype, docname):
|
||||
import webnotes.modules
|
||||
webnotes.connect()
|
||||
webnotes.modules.export_doc(doctype, docname)
|
||||
webnotes.destroy()
|
||||
import frappe.modules
|
||||
frappe.connect()
|
||||
frappe.modules.export_doc(doctype, docname)
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def export_doclist(doctype, name, path):
|
||||
from webnotes.core.page.data_import_tool import data_import_tool
|
||||
webnotes.connect()
|
||||
from frappe.core.page.data_import_tool import data_import_tool
|
||||
frappe.connect()
|
||||
data_import_tool.export_json(doctype, name, path)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def export_csv(doctype, path):
|
||||
from webnotes.core.page.data_import_tool import data_import_tool
|
||||
webnotes.connect()
|
||||
from frappe.core.page.data_import_tool import data_import_tool
|
||||
frappe.connect()
|
||||
data_import_tool.export_csv(doctype, path)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def import_doclist(path, force=False):
|
||||
from webnotes.core.page.data_import_tool import data_import_tool
|
||||
webnotes.connect()
|
||||
from frappe.core.page.data_import_tool import data_import_tool
|
||||
frappe.connect()
|
||||
data_import_tool.import_doclist(path, overwrite=force)
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
# translation
|
||||
@cmd
|
||||
def build_message_files():
|
||||
import webnotes.translate
|
||||
webnotes.connect()
|
||||
webnotes.translate.rebuild_all_translation_files()
|
||||
webnotes.destroy()
|
||||
import frappe.translate
|
||||
frappe.connect()
|
||||
frappe.translate.rebuild_all_translation_files()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def get_untranslated(lang, untranslated_file):
|
||||
import webnotes.translate
|
||||
webnotes.connect()
|
||||
webnotes.translate.get_untranslated(lang, untranslated_file)
|
||||
webnotes.destroy()
|
||||
import frappe.translate
|
||||
frappe.connect()
|
||||
frappe.translate.get_untranslated(lang, untranslated_file)
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def update_translations(lang, untranslated_file, translated_file):
|
||||
import webnotes.translate
|
||||
webnotes.connect()
|
||||
webnotes.translate.update_translations(lang, untranslated_file, translated_file)
|
||||
webnotes.destroy()
|
||||
import frappe.translate
|
||||
frappe.connect()
|
||||
frappe.translate.update_translations(lang, untranslated_file, translated_file)
|
||||
frappe.destroy()
|
||||
|
||||
# git
|
||||
@cmd
|
||||
|
|
@ -545,12 +545,12 @@ def git(param):
|
|||
|
||||
def get_remote_and_branch(remote=None, branch=None):
|
||||
if not (remote and branch):
|
||||
if not webnotes.conf.branch:
|
||||
if not frappe.conf.branch:
|
||||
raise Exception("Please specify remote and branch")
|
||||
|
||||
remote = remote or "origin"
|
||||
branch = branch or webnotes.conf.branch
|
||||
webnotes.destroy()
|
||||
branch = branch or frappe.conf.branch
|
||||
frappe.destroy()
|
||||
|
||||
return remote, branch
|
||||
|
||||
|
|
@ -578,36 +578,36 @@ def checkout(branch):
|
|||
|
||||
@cmd
|
||||
def set_admin_password(admin_password):
|
||||
import webnotes
|
||||
webnotes.connect()
|
||||
webnotes.conn.sql("""update __Auth set `password`=password(%s)
|
||||
import frappe
|
||||
frappe.connect()
|
||||
frappe.conn.sql("""update __Auth set `password`=password(%s)
|
||||
where user='Administrator'""", (admin_password,))
|
||||
webnotes.conn.commit()
|
||||
webnotes.destroy()
|
||||
frappe.conn.commit()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def mysql():
|
||||
import webnotes
|
||||
import frappe
|
||||
import commands, os
|
||||
msq = commands.getoutput('which mysql')
|
||||
os.execv(msq, [msq, '-u', webnotes.conf.db_name, '-p'+webnotes.conf.db_password, webnotes.conf.db_name, '-h', webnotes.conf.db_host or "localhost", "-A"])
|
||||
webnotes.destroy()
|
||||
os.execv(msq, [msq, '-u', frappe.conf.db_name, '-p'+frappe.conf.db_password, frappe.conf.db_name, '-h', frappe.conf.db_host or "localhost", "-A"])
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def python(site):
|
||||
import webnotes
|
||||
import frappe
|
||||
import commands, os
|
||||
python = commands.getoutput('which python')
|
||||
if site:
|
||||
os.environ["site"] = site
|
||||
os.environ["PYTHONSTARTUP"] = os.path.join(os.path.dirname(webnotes.__file__), "pythonrc.py")
|
||||
os.environ["PYTHONSTARTUP"] = os.path.join(os.path.dirname(frappe.__file__), "pythonrc.py")
|
||||
os.execv(python, [python])
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def ipython():
|
||||
import webnotes
|
||||
webnotes.connect()
|
||||
import frappe
|
||||
frappe.connect()
|
||||
import IPython
|
||||
IPython.embed()
|
||||
|
||||
|
|
@ -619,44 +619,44 @@ def smtp_debug_server():
|
|||
|
||||
@cmd
|
||||
def run_tests(app=None, module=None, doctype=None, verbose=False):
|
||||
import webnotes.test_runner
|
||||
ret = webnotes.test_runner.main(app and app[0], module and module[0], doctype and doctype[0], verbose)
|
||||
import frappe.test_runner
|
||||
ret = frappe.test_runner.main(app and app[0], module and module[0], doctype and doctype[0], verbose)
|
||||
if len(ret.failures) > 0 or len(ret.errors) > 0:
|
||||
exit(1)
|
||||
|
||||
@cmd
|
||||
def serve(port=8000, profile=False):
|
||||
import webnotes.app
|
||||
webnotes.app.serve(port=port, profile=profile, site=webnotes.local.site)
|
||||
import frappe.app
|
||||
frappe.app.serve(port=port, profile=profile, site=frappe.local.site)
|
||||
|
||||
@cmd
|
||||
def request(args):
|
||||
import webnotes.handler
|
||||
import webnotes.api
|
||||
webnotes.connect()
|
||||
import frappe.handler
|
||||
import frappe.api
|
||||
frappe.connect()
|
||||
if "?" in args:
|
||||
webnotes.local.form_dict = webnotes._dict([a.split("=") for a in args.split("?")[-1].split("&")])
|
||||
frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")])
|
||||
else:
|
||||
webnotes.local.form_dict = webnotes._dict()
|
||||
frappe.local.form_dict = frappe._dict()
|
||||
|
||||
if args.startswith("/api/method"):
|
||||
webnotes.local.form_dict.cmd = args.split("?")[0].split("/")[-1]
|
||||
frappe.local.form_dict.cmd = args.split("?")[0].split("/")[-1]
|
||||
|
||||
webnotes.handler.execute_cmd(webnotes.form_dict.cmd)
|
||||
frappe.handler.execute_cmd(frappe.form_dict.cmd)
|
||||
|
||||
print webnotes.response
|
||||
webnotes.destroy()
|
||||
print frappe.response
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def flush_memcache():
|
||||
webnotes.cache().flush_all()
|
||||
frappe.cache().flush_all()
|
||||
|
||||
|
||||
def replace_code(start, txt1, txt2, extn, search=None, force=False):
|
||||
"""replace all txt1 by txt2 in files with extension (extn)"""
|
||||
import webnotes.utils
|
||||
import frappe.utils
|
||||
import os, re
|
||||
esc = webnotes.utils.make_esc('[]')
|
||||
esc = frappe.utils.make_esc('[]')
|
||||
if not search: search = esc(txt1)
|
||||
for wt in os.walk(start, followlinks=1):
|
||||
for fn in wt[2]:
|
||||
|
|
@ -700,28 +700,28 @@ def search_replace_with_prompt(fpath, txt1, txt2, force=False):
|
|||
|
||||
@cmd
|
||||
def get_site_status(verbose=False):
|
||||
import webnotes
|
||||
import webnotes.utils
|
||||
from webnotes.profile import get_system_managers
|
||||
from webnotes.core.doctype.profile.profile import get_total_users, get_active_users, \
|
||||
import frappe
|
||||
import frappe.utils
|
||||
from frappe.profile import get_system_managers
|
||||
from frappe.core.doctype.profile.profile import get_total_users, get_active_users, \
|
||||
get_website_users, get_active_website_users
|
||||
|
||||
import json
|
||||
webnotes.connect()
|
||||
frappe.connect()
|
||||
ret = {
|
||||
'last_backup_on': webnotes.local.conf.last_backup_on,
|
||||
'last_backup_on': frappe.local.conf.last_backup_on,
|
||||
'active_users': get_active_users(),
|
||||
'total_users': get_total_users(),
|
||||
'active_website_users': get_active_website_users(),
|
||||
'website_users': get_website_users(),
|
||||
'system_managers': "\n".join(get_system_managers()),
|
||||
'default_company': webnotes.conn.get_default("company"),
|
||||
'disk_usage': webnotes.utils.get_disk_usage(),
|
||||
'working_directory': webnotes.local.site_path
|
||||
'default_company': frappe.conn.get_default("company"),
|
||||
'disk_usage': frappe.utils.get_disk_usage(),
|
||||
'working_directory': frappe.local.site_path
|
||||
}
|
||||
|
||||
# country, timezone, industry
|
||||
control_panel_details = webnotes.conn.get_value("Control Panel", "Control Panel",
|
||||
control_panel_details = frappe.conn.get_value("Control Panel", "Control Panel",
|
||||
["country", "time_zone", "industry"], as_dict=True)
|
||||
if control_panel_details:
|
||||
ret.update(control_panel_details)
|
||||
|
|
@ -730,9 +730,9 @@ def get_site_status(verbose=False):
|
|||
for doctype in ("Company", "Customer", "Item", "Quotation", "Sales Invoice",
|
||||
"Journal Voucher", "Stock Ledger Entry"):
|
||||
key = doctype.lower().replace(" ", "_") + "_exists"
|
||||
ret[key] = 1 if webnotes.conn.count(doctype) else 0
|
||||
ret[key] = 1 if frappe.conn.count(doctype) else 0
|
||||
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
if verbose:
|
||||
print json.dumps(ret, indent=1, sort_keys=True)
|
||||
|
|
@ -746,14 +746,14 @@ def update_site_config(site_config, verbose=False):
|
|||
if isinstance(site_config, basestring):
|
||||
site_config = json.loads(site_config)
|
||||
|
||||
config = webnotes.get_site_config()
|
||||
config = frappe.get_site_config()
|
||||
config.update(site_config)
|
||||
site_config_path = os.path.join(webnotes.local.site_path, "site_config.json")
|
||||
site_config_path = os.path.join(frappe.local.site_path, "site_config.json")
|
||||
|
||||
with open(site_config_path, "w") as f:
|
||||
json.dump(config, f, indent=1, sort_keys=True)
|
||||
|
||||
webnotes.destroy()
|
||||
frappe.destroy()
|
||||
|
||||
@cmd
|
||||
def bump(repo, bump_type):
|
||||
|
|
@ -2,48 +2,48 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
from webnotes import _
|
||||
import webnotes.model
|
||||
import webnotes.utils
|
||||
import frappe
|
||||
from frappe import _
|
||||
import frappe.model
|
||||
import frappe.utils
|
||||
import json, os
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get(doctype, name=None, filters=None):
|
||||
if filters and not name:
|
||||
name = webnotes.conn.get_value(doctype, json.loads(filters))
|
||||
name = frappe.conn.get_value(doctype, json.loads(filters))
|
||||
if not name:
|
||||
raise Exception, "No document found for given filters"
|
||||
return [d.fields for d in webnotes.bean(doctype, name).doclist]
|
||||
return [d.fields for d in frappe.bean(doctype, name).doclist]
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get_value(doctype, fieldname, filters=None, as_dict=True, debug=False):
|
||||
if not webnotes.has_permission(doctype):
|
||||
webnotes.msgprint("No Permission", raise_exception=True)
|
||||
if not frappe.has_permission(doctype):
|
||||
frappe.msgprint("No Permission", raise_exception=True)
|
||||
|
||||
if fieldname and fieldname.startswith("["):
|
||||
fieldname = json.loads(fieldname)
|
||||
return webnotes.conn.get_value(doctype, json.loads(filters), fieldname, as_dict=as_dict, debug=debug)
|
||||
return frappe.conn.get_value(doctype, json.loads(filters), fieldname, as_dict=as_dict, debug=debug)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def set_value(doctype, name, fieldname, value):
|
||||
if fieldname in webnotes.model.default_fields:
|
||||
webnotes.throw(_("Cannot edit standard fields"))
|
||||
if fieldname in frappe.model.default_fields:
|
||||
frappe.throw(_("Cannot edit standard fields"))
|
||||
|
||||
doc = webnotes.conn.get_value(doctype, name, ["parenttype", "parent"], as_dict=True)
|
||||
doc = frappe.conn.get_value(doctype, name, ["parenttype", "parent"], as_dict=True)
|
||||
if doc and doc.parent:
|
||||
bean = webnotes.bean(doc.parenttype, doc.parent)
|
||||
bean = frappe.bean(doc.parenttype, doc.parent)
|
||||
child = bean.doclist.getone({"doctype": doctype, "name": name})
|
||||
child.fields[fieldname] = value
|
||||
else:
|
||||
bean = webnotes.bean(doctype, name)
|
||||
bean = frappe.bean(doctype, name)
|
||||
bean.doc.fields[fieldname] = value
|
||||
|
||||
bean.save()
|
||||
|
||||
return [d.fields for d in bean.doclist]
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def insert(doclist):
|
||||
if isinstance(doclist, basestring):
|
||||
doclist = json.loads(doclist)
|
||||
|
|
@ -51,57 +51,57 @@ def insert(doclist):
|
|||
doclist[0]["__islocal"] = 1
|
||||
return save(doclist)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def save(doclist):
|
||||
if isinstance(doclist, basestring):
|
||||
doclist = json.loads(doclist)
|
||||
|
||||
doclistobj = webnotes.bean(doclist)
|
||||
doclistobj = frappe.bean(doclist)
|
||||
doclistobj.save()
|
||||
|
||||
return [d.fields for d in doclist]
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def rename_doc(doctype, old_name, new_name, merge=False):
|
||||
new_name = webnotes.rename_doc(doctype, old_name, new_name, merge=merge)
|
||||
new_name = frappe.rename_doc(doctype, old_name, new_name, merge=merge)
|
||||
return new_name
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def submit(doclist):
|
||||
if isinstance(doclist, basestring):
|
||||
doclist = json.loads(doclist)
|
||||
|
||||
doclistobj = webnotes.bean(doclist)
|
||||
doclistobj = frappe.bean(doclist)
|
||||
doclistobj.submit()
|
||||
|
||||
return [d.fields for d in doclist]
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def cancel(doctype, name):
|
||||
wrapper = webnotes.bean(doctype, name)
|
||||
wrapper = frappe.bean(doctype, name)
|
||||
wrapper.cancel()
|
||||
|
||||
return [d.fields for d in wrapper.doclist]
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def delete(doctype, name):
|
||||
webnotes.delete_doc(doctype, name)
|
||||
frappe.delete_doc(doctype, name)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def set_default(key, value, parent=None):
|
||||
"""set a user default value"""
|
||||
webnotes.conn.set_default(key, value, parent or webnotes.session.user)
|
||||
webnotes.clear_cache(user=webnotes.session.user)
|
||||
frappe.conn.set_default(key, value, parent or frappe.session.user)
|
||||
frappe.clear_cache(user=frappe.session.user)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def make_width_property_setter():
|
||||
doclist = json.loads(webnotes.form_dict.doclist)
|
||||
doclist = json.loads(frappe.form_dict.doclist)
|
||||
if doclist[0]["doctype"]=="Property Setter" and doclist[0]["property"]=="width":
|
||||
bean = webnotes.bean(doclist)
|
||||
bean = frappe.bean(doclist)
|
||||
bean.ignore_permissions = True
|
||||
bean.insert()
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def bulk_update(docs):
|
||||
docs = json.loads(docs)
|
||||
failed_docs = []
|
||||
|
|
@ -110,29 +110,29 @@ def bulk_update(docs):
|
|||
ddoc = {key: val for key, val in doc.iteritems() if key not in ['doctype', 'docname']}
|
||||
doctype = doc['doctype']
|
||||
docname = doc['docname']
|
||||
bean = webnotes.bean(doctype, docname)
|
||||
bean = frappe.bean(doctype, docname)
|
||||
bean.doc.update(ddoc)
|
||||
bean.save()
|
||||
except:
|
||||
failed_docs.append({
|
||||
'doc': doc,
|
||||
'exc': webnotes.utils.get_traceback()
|
||||
'exc': frappe.utils.get_traceback()
|
||||
})
|
||||
return {'failed_docs': failed_docs}
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def has_permission(doctype, docname, perm_type="read"):
|
||||
# perm_type can be one of read, write, create, submit, cancel, report
|
||||
return {"has_permission": webnotes.has_permission(doctype, perm_type.lower(), docname)}
|
||||
return {"has_permission": frappe.has_permission(doctype, perm_type.lower(), docname)}
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get_js(src):
|
||||
contentpath = os.path.join(webnotes.local.sites_path, src)
|
||||
contentpath = os.path.join(frappe.local.sites_path, src)
|
||||
with open(contentpath, "r") as srcfile:
|
||||
code = srcfile.read()
|
||||
|
||||
if webnotes.local.lang != "en":
|
||||
if frappe.local.lang != "en":
|
||||
code += "\n\n$.extend(wn._messages, {})".format(json.dumps(\
|
||||
webnotes.get_lang_dict("jsfile", contentpath)))
|
||||
frappe.get_lang_dict("jsfile", contentpath)))
|
||||
return code
|
||||
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
from webnotes import _
|
||||
from frappe import _
|
||||
|
||||
data = {
|
||||
"Calendar": {
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
from webnotes import _
|
||||
from frappe import _
|
||||
|
||||
data = [
|
||||
{
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,16 +2,16 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes, json
|
||||
import frappe, json
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
self.doc, self.doclist = d, dl
|
||||
|
||||
def validate(self):
|
||||
if webnotes.conn.sql("""select count(*) from tabComment where comment_doctype=%s
|
||||
if frappe.conn.sql("""select count(*) from tabComment where comment_doctype=%s
|
||||
and comment_docname=%s""", (self.doc.doctype, self.doc.name))[0][0] >= 50:
|
||||
webnotes.msgprint("Max Comments reached!", raise_exception=True)
|
||||
frappe.msgprint("Max Comments reached!", raise_exception=True)
|
||||
|
||||
def on_update(self):
|
||||
self.update_comment_in_doc()
|
||||
|
|
@ -35,7 +35,7 @@ class DocType:
|
|||
self.update_comments_in_parent(_comments)
|
||||
except Exception, e:
|
||||
if e.args[0]==1054:
|
||||
from webnotes.model.db_schema import add_column
|
||||
from frappe.model.db_schema import add_column
|
||||
add_column(self.doc.comment_doctype, "_comments", "Text")
|
||||
self.update_comment_in_doc()
|
||||
elif e.args[0]==1146:
|
||||
|
|
@ -45,13 +45,13 @@ class DocType:
|
|||
raise
|
||||
|
||||
def get_comments_from_parent(self):
|
||||
_comments = webnotes.conn.get_value(self.doc.comment_doctype,
|
||||
_comments = frappe.conn.get_value(self.doc.comment_doctype,
|
||||
self.doc.comment_docname, "_comments") or "[]"
|
||||
return json.loads(_comments)
|
||||
|
||||
def update_comments_in_parent(self, _comments):
|
||||
# use sql, so that we do not mess with the timestamp
|
||||
webnotes.conn.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (self.doc.comment_doctype,
|
||||
frappe.conn.sql("""update `tab%s` set `_comments`=%s where name=%s""" % (self.doc.comment_doctype,
|
||||
"%s", "%s"), (json.dumps(_comments), self.doc.comment_docname))
|
||||
|
||||
def on_trash(self):
|
||||
|
|
@ -63,8 +63,8 @@ class DocType:
|
|||
self.update_comments_in_parent(_comments)
|
||||
|
||||
def on_doctype_update():
|
||||
if not webnotes.conn.sql("""show index from `tabComment`
|
||||
if not frappe.conn.sql("""show index from `tabComment`
|
||||
where Key_name="comment_doctype_docname_index" """):
|
||||
webnotes.conn.commit()
|
||||
webnotes.conn.sql("""alter table `tabComment`
|
||||
frappe.conn.commit()
|
||||
frappe.conn.sql("""alter table `tabComment`
|
||||
add index comment_doctype_docname_index(comment_doctype, comment_docname)""")
|
||||
|
|
@ -2,14 +2,14 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes, unittest, json
|
||||
import frappe, unittest, json
|
||||
|
||||
# commented due to commits -- only run when comments are modified
|
||||
|
||||
# class TestComment(unittest.TestCase):
|
||||
# def setUp(self):
|
||||
# self.cleanup()
|
||||
# self.test_rec = webnotes.bean({
|
||||
# self.test_rec = frappe.bean({
|
||||
# "doctype":"Event",
|
||||
# "subject":"__Comment Test Event",
|
||||
# "event_type": "Private",
|
||||
|
|
@ -21,29 +21,29 @@ import webnotes, unittest, json
|
|||
# self.cleanup()
|
||||
#
|
||||
# def cleanup(self):
|
||||
# webnotes.conn.sql("""delete from tabEvent where subject='__Comment Test Event'""")
|
||||
# webnotes.conn.sql("""delete from tabComment where comment='__Test Comment'""")
|
||||
# webnotes.conn.commit()
|
||||
# if "_comments" in webnotes.conn.get_table_columns("Event"):
|
||||
# webnotes.conn.commit()
|
||||
# webnotes.conn.sql("""alter table `tabEvent` drop column `_comments`""")
|
||||
# frappe.conn.sql("""delete from tabEvent where subject='__Comment Test Event'""")
|
||||
# frappe.conn.sql("""delete from tabComment where comment='__Test Comment'""")
|
||||
# frappe.conn.commit()
|
||||
# if "_comments" in frappe.conn.get_table_columns("Event"):
|
||||
# frappe.conn.commit()
|
||||
# frappe.conn.sql("""alter table `tabEvent` drop column `_comments`""")
|
||||
#
|
||||
# def test_add_comment(self):
|
||||
# self.comment = webnotes.bean({
|
||||
# self.comment = frappe.bean({
|
||||
# "doctype":"Comment",
|
||||
# "comment_doctype": self.test_rec.doc.doctype,
|
||||
# "comment_docname": self.test_rec.doc.name,
|
||||
# "comment": "__Test Comment"
|
||||
# }).insert()
|
||||
#
|
||||
# test_rec = webnotes.doc(self.test_rec.doc.doctype, self.test_rec.doc.name)
|
||||
# test_rec = frappe.doc(self.test_rec.doc.doctype, self.test_rec.doc.name)
|
||||
# _comments = json.loads(test_rec.get("_comments"))
|
||||
# self.assertTrue(_comments[0].get("comment")=="__Test Comment")
|
||||
#
|
||||
# def test_remove_comment(self):
|
||||
# self.test_add_comment()
|
||||
# webnotes.delete_doc("Comment", self.comment.doc.name)
|
||||
# test_rec = webnotes.doc(self.test_rec.doc.doctype, self.test_rec.doc.name)
|
||||
# frappe.delete_doc("Comment", self.comment.doc.name)
|
||||
# test_rec = frappe.doc(self.test_rec.doc.doctype, self.test_rec.doc.name)
|
||||
# _comments = json.loads(test_rec.get("_comments"))
|
||||
# self.assertEqual(len(_comments), 0)
|
||||
#
|
||||
10
frappe/core/doctype/communication/communication.js
Normal file
10
frappe/core/doctype/communication/communication.js
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
cur_frm.cscript.onload = function(doc) {
|
||||
cur_frm.fields_dict.user.get_query = function() {
|
||||
return {
|
||||
query: "frappe.core.doctype.communication.communication.get_user"
|
||||
}
|
||||
};
|
||||
|
||||
if(doc.content)
|
||||
doc.content = frappe.utils.remove_script_and_style(doc.content);
|
||||
}
|
||||
|
|
@ -2,15 +2,15 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
import json
|
||||
import urllib
|
||||
from email.utils import formataddr
|
||||
from webnotes.website.utils import is_signup_enabled
|
||||
from webnotes.utils import get_url, cstr
|
||||
from webnotes.utils.email_lib.email_body import get_email
|
||||
from webnotes.utils.email_lib.smtp import send
|
||||
from webnotes.utils import scrub_urls
|
||||
from frappe.website.utils import is_signup_enabled
|
||||
from frappe.utils import get_url, cstr
|
||||
from frappe.utils.email_lib.email_body import get_email
|
||||
from frappe.utils.email_lib.smtp import send
|
||||
from frappe.utils import scrub_urls
|
||||
|
||||
class DocType():
|
||||
def __init__(self, doc, doclist=None):
|
||||
|
|
@ -18,7 +18,7 @@ class DocType():
|
|||
self.doclist = doclist
|
||||
|
||||
def get_parent_bean(self):
|
||||
return webnotes.bean(self.doc.parenttype, self.doc.parent)
|
||||
return frappe.bean(self.doc.parenttype, self.doc.parent)
|
||||
|
||||
def update_parent(self):
|
||||
"""update status of parent Lead or Contact based on who is replying"""
|
||||
|
|
@ -29,13 +29,13 @@ class DocType():
|
|||
def on_update(self):
|
||||
self.update_parent()
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def make(doctype=None, name=None, content=None, subject=None, sent_or_received = "Sent",
|
||||
sender=None, recipients=None, communication_medium="Email", send_email=False,
|
||||
print_html=None, attachments='[]', send_me_a_copy=False, set_lead=True, date=None):
|
||||
|
||||
if doctype and name and not webnotes.has_permission(doctype, "email", name):
|
||||
raise webnotes.PermissionError("You are not allowed to send emails related to: {doctype} {name}".format(
|
||||
if doctype and name and not frappe.has_permission(doctype, "email", name):
|
||||
raise frappe.PermissionError("You are not allowed to send emails related to: {doctype} {name}".format(
|
||||
doctype=doctype, name=name))
|
||||
|
||||
_make(doctype=doctype, name=name, content=content, subject=subject, sent_or_received=sent_or_received,
|
||||
|
|
@ -60,16 +60,16 @@ def _make(doctype=None, name=None, content=None, subject=None, sent_or_received
|
|||
if isinstance(sender, (tuple, list)) and len(sender)==2:
|
||||
sender = formataddr(sender)
|
||||
|
||||
comm = webnotes.new_bean('Communication')
|
||||
comm = frappe.new_bean('Communication')
|
||||
d = comm.doc
|
||||
d.subject = subject
|
||||
d.content = content
|
||||
d.sent_or_received = sent_or_received
|
||||
d.sender = sender or webnotes.conn.get_value("Profile", webnotes.session.user, "email")
|
||||
d.sender = sender or frappe.conn.get_value("Profile", frappe.session.user, "email")
|
||||
d.recipients = recipients
|
||||
|
||||
# add as child
|
||||
sent_via = webnotes.get_obj(doctype, name)
|
||||
sent_via = frappe.get_obj(doctype, name)
|
||||
d.parent = name
|
||||
d.parenttype = doctype
|
||||
d.parentfield = "communications"
|
||||
|
|
@ -86,15 +86,15 @@ def _make(doctype=None, name=None, content=None, subject=None, sent_or_received
|
|||
d = comm.doc
|
||||
send_comm_email(d, name, sent_via, print_html, attachments, send_me_a_copy)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get_customer_supplier(args=None):
|
||||
"""
|
||||
Get Customer/Supplier, given a contact, if a unique match exists
|
||||
"""
|
||||
if not args: args = webnotes.local.form_dict
|
||||
if not args: args = frappe.local.form_dict
|
||||
if not args.get('contact'):
|
||||
raise Exception, "Please specify a contact to fetch Customer/Supplier"
|
||||
result = webnotes.conn.sql("""\
|
||||
result = frappe.conn.sql("""\
|
||||
select customer, supplier
|
||||
from `tabContact`
|
||||
where name = %s""", args.get('contact'), as_dict=1)
|
||||
|
|
@ -118,7 +118,7 @@ def send_comm_email(d, name, sent_via=None, print_html=None, attachments='[]', s
|
|||
|
||||
footer = set_portal_link(sent_via, d)
|
||||
|
||||
send_print_in_body = webnotes.conn.get_value("Email Settings", None, "send_print_in_body_and_attachment")
|
||||
send_print_in_body = frappe.conn.get_value("Email Settings", None, "send_print_in_body_and_attachment")
|
||||
if not send_print_in_body:
|
||||
d.content += "<p>Please see attachment for document details.</p>"
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ def send_comm_email(d, name, sent_via=None, print_html=None, attachments='[]', s
|
|||
msg=d.content, footer=footer, print_html=print_html if send_print_in_body else None)
|
||||
|
||||
if send_me_a_copy:
|
||||
mail.cc.append(webnotes.conn.get_value("Profile", webnotes.session.user, "email"))
|
||||
mail.cc.append(frappe.conn.get_value("Profile", frappe.session.user, "email"))
|
||||
|
||||
if print_html:
|
||||
print_html = scrub_urls(print_html)
|
||||
|
|
@ -136,7 +136,7 @@ def send_comm_email(d, name, sent_via=None, print_html=None, attachments='[]', s
|
|||
try:
|
||||
mail.attach_file(a)
|
||||
except IOError, e:
|
||||
webnotes.msgprint("""Unable to find attachment %s. Please resend without attaching this file.""" % a,
|
||||
frappe.msgprint("""Unable to find attachment %s. Please resend without attaching this file.""" % a,
|
||||
raise_exception=True)
|
||||
|
||||
send(mail)
|
||||
|
|
@ -2,10 +2,10 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
from webnotes import form, msgprint
|
||||
import webnotes.defaults
|
||||
from frappe import form, msgprint
|
||||
import frappe.defaults
|
||||
|
||||
class DocType:
|
||||
def __init__(self, doc, doclist):
|
||||
|
|
@ -14,5 +14,5 @@ class DocType:
|
|||
|
||||
def on_update(self):
|
||||
# clear cache on save
|
||||
webnotes.cache().delete_value('time_zone')
|
||||
webnotes.clear_cache()
|
||||
frappe.cache().delete_value('time_zone')
|
||||
frappe.clear_cache()
|
||||
|
|
@ -58,8 +58,8 @@ cur_frm.cscript.dt = function(doc, dt, dn) {
|
|||
set_field_options('insert_after', '');
|
||||
return;
|
||||
}
|
||||
return wn.call({
|
||||
method: 'webnotes.core.doctype.custom_field.custom_field.get_fields_label',
|
||||
return frappe.call({
|
||||
method: 'frappe.core.doctype.custom_field.custom_field.get_fields_label',
|
||||
args: { doctype: doc.dt, fieldname: doc.fieldname },
|
||||
callback: function(r, rt) {
|
||||
doc = locals[doc.doctype][doc.name];
|
||||
|
|
@ -2,9 +2,9 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
from webnotes.utils import cint, cstr
|
||||
from webnotes import _
|
||||
import frappe
|
||||
from frappe.utils import cint, cstr
|
||||
from frappe import _
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -17,13 +17,13 @@ class DocType:
|
|||
def set_fieldname(self):
|
||||
if not self.doc.fieldname:
|
||||
if not self.doc.label:
|
||||
webnotes.throw(_("Label is mandatory"))
|
||||
frappe.throw(_("Label is mandatory"))
|
||||
# remove special characters from fieldname
|
||||
self.doc.fieldname = filter(lambda x: x.isdigit() or x.isalpha() or '_',
|
||||
cstr(self.doc.label).lower().replace(' ','_'))
|
||||
|
||||
def validate(self):
|
||||
from webnotes.model.doctype import get
|
||||
from frappe.model.doctype import get
|
||||
temp_doclist = get(self.doc.dt).get_parent_doclist()
|
||||
|
||||
# set idx
|
||||
|
|
@ -33,28 +33,28 @@ class DocType:
|
|||
|
||||
def on_update(self):
|
||||
# validate field
|
||||
from webnotes.core.doctype.doctype.doctype import validate_fields_for_doctype
|
||||
from frappe.core.doctype.doctype.doctype import validate_fields_for_doctype
|
||||
|
||||
validate_fields_for_doctype(self.doc.dt)
|
||||
|
||||
webnotes.clear_cache(doctype=self.doc.dt)
|
||||
frappe.clear_cache(doctype=self.doc.dt)
|
||||
|
||||
# create property setter to emulate insert after
|
||||
self.create_property_setter()
|
||||
|
||||
# update the schema
|
||||
from webnotes.model.db_schema import updatedb
|
||||
from frappe.model.db_schema import updatedb
|
||||
updatedb(self.doc.dt)
|
||||
|
||||
def on_trash(self):
|
||||
# delete property setter entries
|
||||
webnotes.conn.sql("""\
|
||||
frappe.conn.sql("""\
|
||||
DELETE FROM `tabProperty Setter`
|
||||
WHERE doc_type = %s
|
||||
AND field_name = %s""",
|
||||
(self.doc.dt, self.doc.fieldname))
|
||||
|
||||
webnotes.clear_cache(doctype=self.doc.dt)
|
||||
frappe.clear_cache(doctype=self.doc.dt)
|
||||
|
||||
def create_property_setter(self):
|
||||
if not self.doc.insert_after: return
|
||||
|
|
@ -63,35 +63,35 @@ class DocType:
|
|||
if label_index==-1: return
|
||||
|
||||
prev_field = field_list[label_index]
|
||||
webnotes.conn.sql("""\
|
||||
frappe.conn.sql("""\
|
||||
DELETE FROM `tabProperty Setter`
|
||||
WHERE doc_type = %s
|
||||
AND field_name = %s
|
||||
AND property = 'previous_field'""", (self.doc.dt, self.doc.fieldname))
|
||||
|
||||
webnotes.make_property_setter({
|
||||
frappe.make_property_setter({
|
||||
"doctype":self.doc.dt,
|
||||
"fieldname": self.doc.fieldname,
|
||||
"property": "previous_field",
|
||||
"value": prev_field
|
||||
})
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get_fields_label(dt=None, form=1):
|
||||
"""
|
||||
if form=1: Returns a string of field labels separated by \n
|
||||
if form=0: Returns lists of field labels and field names
|
||||
"""
|
||||
import webnotes
|
||||
from webnotes.utils import cstr
|
||||
import webnotes.model.doctype
|
||||
import frappe
|
||||
from frappe.utils import cstr
|
||||
import frappe.model.doctype
|
||||
fieldname = None
|
||||
if not dt:
|
||||
dt = webnotes.form_dict.get('doctype')
|
||||
fieldname = webnotes.form_dict.get('fieldname')
|
||||
dt = frappe.form_dict.get('doctype')
|
||||
fieldname = frappe.form_dict.get('fieldname')
|
||||
if not dt: return ""
|
||||
|
||||
doclist = webnotes.model.doctype.get(dt)
|
||||
doclist = frappe.model.doctype.get(dt)
|
||||
docfields = sorted(doclist.get({"parent": dt, "doctype": "DocField"}),
|
||||
key=lambda d: d.idx)
|
||||
|
||||
|
|
@ -109,12 +109,12 @@ def get_fields_label(dt=None, form=1):
|
|||
return idx_label_list, field_list
|
||||
|
||||
def create_custom_field_if_values_exist(doctype, df):
|
||||
df = webnotes._dict(df)
|
||||
if df.fieldname in webnotes.conn.get_table_columns(doctype) and \
|
||||
webnotes.conn.sql("""select count(*) from `tab{doctype}`
|
||||
df = frappe._dict(df)
|
||||
if df.fieldname in frappe.conn.get_table_columns(doctype) and \
|
||||
frappe.conn.sql("""select count(*) from `tab{doctype}`
|
||||
where ifnull({fieldname},'')!=''""".format(doctype=doctype, fieldname=df.fieldname))[0][0] and \
|
||||
not webnotes.conn.get_value("Custom Field", {"dt": doctype, "fieldname": df.fieldname}):
|
||||
webnotes.bean({
|
||||
not frappe.conn.get_value("Custom Field", {"dt": doctype, "fieldname": df.fieldname}):
|
||||
frappe.bean({
|
||||
"doctype":"Custom Field",
|
||||
"dt": doctype,
|
||||
"permlevel": df.permlevel or 0,
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
|
||||
# MIT License. See license.txt
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
from webnotes.utils import cstr
|
||||
import frappe
|
||||
from frappe.utils import cstr
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -12,8 +12,8 @@ class DocType:
|
|||
self.doc.name = self.doc.dt + "-" + self.doc.script_type
|
||||
|
||||
def on_update(self):
|
||||
webnotes.clear_cache(doctype=self.doc.dt)
|
||||
frappe.clear_cache(doctype=self.doc.dt)
|
||||
|
||||
def on_trash(self):
|
||||
webnotes.clear_cache(doctype=self.doc.dt)
|
||||
frappe.clear_cache(doctype=self.doc.dt)
|
||||
|
||||
|
|
@ -70,9 +70,9 @@ cur_frm.cscript.refresh = function() {
|
|||
|
||||
cur_frm.cscript.hide_allow_attach(cur_frm.doc);
|
||||
|
||||
if(wn.route_options) {
|
||||
wn.model.set_value("Customize Form", null, "doc_type", wn.route_options.doctype)
|
||||
wn.route_options = null;
|
||||
if(frappe.route_options) {
|
||||
frappe.model.set_value("Customize Form", null, "doc_type", frappe.route_options.doctype)
|
||||
frappe.route_options = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -97,7 +97,7 @@ cur_frm.cscript.hide_allow_attach = function(doc) {
|
|||
}
|
||||
|
||||
cur_frm.confirm = function(msg, doc, dt, dn) {
|
||||
var d = new wn.ui.Dialog({
|
||||
var d = new frappe.ui.Dialog({
|
||||
title: 'Reset To Defaults',
|
||||
width: 500
|
||||
});
|
||||
|
|
@ -145,7 +145,7 @@ cur_frm.add_fields_help = function() {
|
|||
<a id="fields_help" class="link_type">Help</a>\
|
||||
</div>');
|
||||
$('#fields_help').click(function() {
|
||||
var d = new wn.ui.Dialog({
|
||||
var d = new frappe.ui.Dialog({
|
||||
title: 'Help: Field Properties',
|
||||
width: 600
|
||||
});
|
||||
|
|
@ -6,8 +6,8 @@ from __future__ import unicode_literals
|
|||
Customize Form is a Single DocType used to mask the Property Setter
|
||||
Thus providing a better UI from user perspective
|
||||
"""
|
||||
import webnotes, json
|
||||
from webnotes.utils import cstr
|
||||
import frappe, json
|
||||
from frappe.utils import cstr
|
||||
|
||||
class DocType:
|
||||
def __init__(self, doc, doclist=[]):
|
||||
|
|
@ -57,7 +57,7 @@ class DocType:
|
|||
self.clear()
|
||||
|
||||
if self.doc.doc_type:
|
||||
from webnotes.model.doc import addchild
|
||||
from frappe.model.doc import addchild
|
||||
|
||||
for d in self.get_ref_doclist():
|
||||
if d.doctype=='DocField':
|
||||
|
|
@ -80,10 +80,10 @@ class DocType:
|
|||
* Applies property setter properties on the doclist
|
||||
* returns the modified doclist
|
||||
"""
|
||||
from webnotes.model.doctype import get
|
||||
from frappe.model.doctype import get
|
||||
|
||||
ref_doclist = get(self.doc.doc_type)
|
||||
ref_doclist = webnotes.doclist([ref_doclist[0]]
|
||||
ref_doclist = frappe.doclist([ref_doclist[0]]
|
||||
+ ref_doclist.get({"parent": self.doc.doc_type}))
|
||||
|
||||
return ref_doclist
|
||||
|
|
@ -120,7 +120,7 @@ class DocType:
|
|||
for f in args['list']:
|
||||
args['doc_to_set'].fields[f] = args['doc'].fields.get(f)
|
||||
else:
|
||||
webnotes.msgprint("Please specify args['list'] to set", raise_exception=1)
|
||||
frappe.msgprint("Please specify args['list'] to set", raise_exception=1)
|
||||
|
||||
|
||||
def post(self):
|
||||
|
|
@ -128,10 +128,10 @@ class DocType:
|
|||
Save diff between Customize Form Bean and DocType Bean as property setter entries
|
||||
"""
|
||||
if self.doc.doc_type:
|
||||
from webnotes.model import doc
|
||||
from webnotes.core.doctype.doctype.doctype import validate_fields_for_doctype
|
||||
from frappe.model import doc
|
||||
from frappe.core.doctype.doctype.doctype import validate_fields_for_doctype
|
||||
|
||||
this_doclist = webnotes.doclist([self.doc] + self.doclist)
|
||||
this_doclist = frappe.doclist([self.doc] + self.doclist)
|
||||
ref_doclist = self.get_ref_doclist()
|
||||
dt_doclist = doc.get('DocType', self.doc.doc_type)
|
||||
|
||||
|
|
@ -146,8 +146,8 @@ class DocType:
|
|||
|
||||
validate_fields_for_doctype(self.doc.doc_type)
|
||||
|
||||
webnotes.clear_cache(doctype=self.doc.doc_type)
|
||||
webnotes.msgprint("Updated")
|
||||
frappe.clear_cache(doctype=self.doc.doc_type)
|
||||
frappe.msgprint("Updated")
|
||||
|
||||
|
||||
def diff(self, new_dl, ref_dl, dt_dl):
|
||||
|
|
@ -174,7 +174,7 @@ class DocType:
|
|||
if self.has_property_changed(ref_d, new_d, prop):
|
||||
# using set_value not bean because validations are called
|
||||
# in the end anyways
|
||||
webnotes.conn.set_value("Custom Field", ref_d.name, prop, new_d.get(prop))
|
||||
frappe.conn.set_value("Custom Field", ref_d.name, prop, new_d.get(prop))
|
||||
else:
|
||||
d = self.prepare_to_set(prop, new_d, ref_d, dt_dl)
|
||||
if d: diff_list.append(d)
|
||||
|
|
@ -193,7 +193,7 @@ class DocType:
|
|||
"""
|
||||
Get fieldtype and default value for properties of a field
|
||||
"""
|
||||
df_defaults = webnotes.conn.sql("""
|
||||
df_defaults = frappe.conn.sql("""
|
||||
SELECT fieldname, fieldtype, `default`, label
|
||||
FROM `tabDocField`
|
||||
WHERE parent='DocField' or parent='DocType'""", as_dict=1)
|
||||
|
|
@ -225,7 +225,7 @@ class DocType:
|
|||
"""
|
||||
# Check if property has changed compared to when it was loaded
|
||||
if self.has_property_changed(ref_d, new_d, prop):
|
||||
#webnotes.msgprint("new: " + str(new_d.fields[prop]) + " | old: " + str(ref_d.fields[prop]))
|
||||
#frappe.msgprint("new: " + str(new_d.fields[prop]) + " | old: " + str(ref_d.fields[prop]))
|
||||
# Check if the new property is same as that in original doctype
|
||||
# If yes, we need to delete the property setter entry
|
||||
for dt_d in dt_doclist:
|
||||
|
|
@ -253,7 +253,7 @@ class DocType:
|
|||
allow_change = True
|
||||
break
|
||||
if not allow_change:
|
||||
webnotes.msgprint("""\
|
||||
frappe.msgprint("""\
|
||||
You cannot change '%s' of '%s' from '%s' to '%s'.
|
||||
%s can only be changed among %s.
|
||||
<i>Ignoring this change and saving.</i>""" % \
|
||||
|
|
@ -267,7 +267,7 @@ class DocType:
|
|||
|
||||
# If the above conditions are fulfilled,
|
||||
# create a property setter doc, but dont save it yet.
|
||||
from webnotes.model.doc import Document
|
||||
from frappe.model.doc import Document
|
||||
d = Document('Property Setter')
|
||||
d.doctype_or_field = ref_d.doctype=='DocField' and 'DocField' or 'DocType'
|
||||
d.doc_type = self.doc.doc_type
|
||||
|
|
@ -294,7 +294,7 @@ class DocType:
|
|||
if d.doctype=="Customize Form Field":
|
||||
fields.append(d.fieldname)
|
||||
|
||||
d = webnotes.doc('Property Setter')
|
||||
d = frappe.doc('Property Setter')
|
||||
d.doctype_or_field = 'DocType'
|
||||
d.doc_type = self.doc.doc_type
|
||||
d.property = "_idx"
|
||||
|
|
@ -312,12 +312,12 @@ class DocType:
|
|||
for d in ps_doclist:
|
||||
# Delete existing property setter entry
|
||||
if not d.fields.get("field_name"):
|
||||
webnotes.conn.sql("""
|
||||
frappe.conn.sql("""
|
||||
DELETE FROM `tabProperty Setter`
|
||||
WHERE doc_type = %(doc_type)s
|
||||
AND property = %(property)s""", d.fields)
|
||||
else:
|
||||
webnotes.conn.sql("""
|
||||
frappe.conn.sql("""
|
||||
DELETE FROM `tabProperty Setter`
|
||||
WHERE doc_type = %(doc_type)s
|
||||
AND field_name = %(field_name)s
|
||||
|
|
@ -334,11 +334,11 @@ class DocType:
|
|||
and resets it to standard
|
||||
"""
|
||||
if self.doc.doc_type:
|
||||
webnotes.conn.sql("""
|
||||
frappe.conn.sql("""
|
||||
DELETE FROM `tabProperty Setter`
|
||||
WHERE doc_type = %s""", self.doc.doc_type)
|
||||
|
||||
webnotes.clear_cache(doctype=self.doc.doc_type)
|
||||
frappe.clear_cache(doctype=self.doc.doc_type)
|
||||
|
||||
self.get()
|
||||
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,21 +2,21 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
self.doc, self.doclist = d, dl
|
||||
|
||||
def on_doctype_update():
|
||||
if not webnotes.conn.sql("""show index from `tabDefaultValue`
|
||||
if not frappe.conn.sql("""show index from `tabDefaultValue`
|
||||
where Key_name="defaultvalue_parent_defkey_index" """):
|
||||
webnotes.conn.commit()
|
||||
webnotes.conn.sql("""alter table `tabDefaultValue`
|
||||
frappe.conn.commit()
|
||||
frappe.conn.sql("""alter table `tabDefaultValue`
|
||||
add index defaultvalue_parent_defkey_index(parent, defkey)""")
|
||||
|
||||
if not webnotes.conn.sql("""show index from `tabDefaultValue`
|
||||
if not frappe.conn.sql("""show index from `tabDefaultValue`
|
||||
where Key_name="defaultvalue_parent_parenttype_index" """):
|
||||
webnotes.conn.commit()
|
||||
webnotes.conn.sql("""alter table `tabDefaultValue`
|
||||
frappe.conn.commit()
|
||||
frappe.conn.sql("""alter table `tabDefaultValue`
|
||||
add index defaultvalue_parent_parenttype_index(parent, parenttype)""")
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -3,12 +3,12 @@
|
|||
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import webnotes
|
||||
from webnotes import msgprint, _
|
||||
import frappe
|
||||
from frappe import msgprint, _
|
||||
import os
|
||||
|
||||
from webnotes.utils import now, cint
|
||||
from webnotes.model import no_value_fields
|
||||
from frappe.utils import now, cint
|
||||
from frappe.model import no_value_fields
|
||||
|
||||
class DocType:
|
||||
def __init__(self, doc=None, doclist=[]):
|
||||
|
|
@ -16,11 +16,11 @@ class DocType:
|
|||
self.doclist = doclist
|
||||
|
||||
def validate(self):
|
||||
if not webnotes.conf.get("developer_mode"):
|
||||
webnotes.throw("Not in Developer Mode! Set in site_config.json")
|
||||
if not frappe.conf.get("developer_mode"):
|
||||
frappe.throw("Not in Developer Mode! Set in site_config.json")
|
||||
for c in [".", "/", "#", "&", "=", ":", "'", '"']:
|
||||
if c in self.doc.name:
|
||||
webnotes.msgprint(c + " not allowed in name", raise_exception=1)
|
||||
frappe.msgprint(c + " not allowed in name", raise_exception=1)
|
||||
self.validate_series()
|
||||
self.scrub_field_names()
|
||||
self.validate_title_field()
|
||||
|
|
@ -30,12 +30,12 @@ class DocType:
|
|||
self.check_link_replacement_error()
|
||||
|
||||
def change_modified_of_parent(self):
|
||||
if webnotes.flags.in_import:
|
||||
if frappe.flags.in_import:
|
||||
return
|
||||
parent_list = webnotes.conn.sql("""SELECT parent
|
||||
parent_list = frappe.conn.sql("""SELECT parent
|
||||
from tabDocField where fieldtype="Table" and options="%s" """ % self.doc.name)
|
||||
for p in parent_list:
|
||||
webnotes.conn.sql('''UPDATE tabDocType SET modified="%s"
|
||||
frappe.conn.sql('''UPDATE tabDocType SET modified="%s"
|
||||
WHERE `name`="%s"''' % (now(), p[0]))
|
||||
|
||||
def scrub_field_names(self):
|
||||
|
|
@ -55,7 +55,7 @@ class DocType:
|
|||
def validate_title_field(self):
|
||||
if self.doc.title_field and \
|
||||
self.doc.title_field not in [d.fieldname for d in self.doclist.get({"doctype":"DocField"})]:
|
||||
webnotes.throw(_("Title field must be a valid fieldname"))
|
||||
frappe.throw(_("Title field must be a valid fieldname"))
|
||||
|
||||
def validate_series(self, autoname=None, name=None):
|
||||
if not autoname: autoname = self.doc.autoname
|
||||
|
|
@ -67,63 +67,63 @@ class DocType:
|
|||
if autoname and (not autoname.startswith('field:')) and (not autoname.startswith('eval:')) \
|
||||
and (not autoname=='Prompt') and (not autoname.startswith('naming_series:')):
|
||||
prefix = autoname.split('.')[0]
|
||||
used_in = webnotes.conn.sql('select name from tabDocType where substring_index(autoname, ".", 1) = %s and name!=%s', (prefix, name))
|
||||
used_in = frappe.conn.sql('select name from tabDocType where substring_index(autoname, ".", 1) = %s and name!=%s', (prefix, name))
|
||||
if used_in:
|
||||
msgprint('<b>Series already in use:</b> The series "%s" is already used in "%s"' % (prefix, used_in[0][0]), raise_exception=1)
|
||||
|
||||
def on_update(self):
|
||||
from webnotes.model.db_schema import updatedb
|
||||
from frappe.model.db_schema import updatedb
|
||||
updatedb(self.doc.name)
|
||||
|
||||
self.change_modified_of_parent()
|
||||
make_module_and_roles(self.doclist)
|
||||
|
||||
from webnotes import conf
|
||||
if (not webnotes.flags.in_import) and conf.get('developer_mode') or 0:
|
||||
from frappe import conf
|
||||
if (not frappe.flags.in_import) and conf.get('developer_mode') or 0:
|
||||
self.export_doc()
|
||||
self.make_controller_template()
|
||||
|
||||
# update index
|
||||
if not self.doc.custom:
|
||||
from webnotes.model.code import load_doctype_module
|
||||
from frappe.model.code import load_doctype_module
|
||||
module = load_doctype_module( self.doc.name, self.doc.module)
|
||||
if hasattr(module, "on_doctype_update"):
|
||||
module.on_doctype_update()
|
||||
webnotes.clear_cache(doctype=self.doc.name)
|
||||
frappe.clear_cache(doctype=self.doc.name)
|
||||
|
||||
def check_link_replacement_error(self):
|
||||
for d in self.doclist.get({"doctype":"DocField", "fieldtype":"Select"}):
|
||||
if (webnotes.conn.get_value("DocField", d.name, "options") or "").startswith("link:") \
|
||||
if (frappe.conn.get_value("DocField", d.name, "options") or "").startswith("link:") \
|
||||
and not d.options.startswith("link:"):
|
||||
webnotes.msgprint("link: type Select fields are getting replaced. Please check for %s" % d.label,
|
||||
frappe.msgprint("link: type Select fields are getting replaced. Please check for %s" % d.label,
|
||||
raise_exception=True)
|
||||
|
||||
def on_trash(self):
|
||||
webnotes.conn.sql("delete from `tabCustom Field` where dt = %s", self.doc.name)
|
||||
webnotes.conn.sql("delete from `tabCustom Script` where dt = %s", self.doc.name)
|
||||
webnotes.conn.sql("delete from `tabProperty Setter` where doc_type = %s", self.doc.name)
|
||||
webnotes.conn.sql("delete from `tabReport` where ref_doctype=%s", self.doc.name)
|
||||
frappe.conn.sql("delete from `tabCustom Field` where dt = %s", self.doc.name)
|
||||
frappe.conn.sql("delete from `tabCustom Script` where dt = %s", self.doc.name)
|
||||
frappe.conn.sql("delete from `tabProperty Setter` where doc_type = %s", self.doc.name)
|
||||
frappe.conn.sql("delete from `tabReport` where ref_doctype=%s", self.doc.name)
|
||||
|
||||
def before_rename(self, old, new, merge=False):
|
||||
if merge:
|
||||
webnotes.throw(_("DocType can not be merged"))
|
||||
frappe.throw(_("DocType can not be merged"))
|
||||
|
||||
def after_rename(self, old, new, merge=False):
|
||||
if self.doc.issingle:
|
||||
webnotes.conn.sql("""update tabSingles set doctype=%s where doctype=%s""", (new, old))
|
||||
frappe.conn.sql("""update tabSingles set doctype=%s where doctype=%s""", (new, old))
|
||||
else:
|
||||
webnotes.conn.sql("rename table `tab%s` to `tab%s`" % (old, new))
|
||||
frappe.conn.sql("rename table `tab%s` to `tab%s`" % (old, new))
|
||||
|
||||
def export_doc(self):
|
||||
from webnotes.modules.export_file import export_to_files
|
||||
from frappe.modules.export_file import export_to_files
|
||||
export_to_files(record_list=[['DocType', self.doc.name]])
|
||||
|
||||
def import_doc(self):
|
||||
from webnotes.modules.import_module import import_from_files
|
||||
from frappe.modules.import_module import import_from_files
|
||||
import_from_files(record_list=[[self.doc.module, 'doctype', self.doc.name]])
|
||||
|
||||
def make_controller_template(self):
|
||||
from webnotes.modules import get_doc_path, get_module_path, scrub
|
||||
from frappe.modules import get_doc_path, get_module_path, scrub
|
||||
|
||||
pypath = os.path.join(get_doc_path(self.doc.module,
|
||||
self.doc.doctype, self.doc.name), scrub(self.doc.name) + '.py')
|
||||
|
|
@ -139,7 +139,7 @@ class DocType:
|
|||
if is_submittable is set, add amended_from docfields
|
||||
"""
|
||||
if self.doc.is_submittable:
|
||||
if not webnotes.conn.sql("""select name from tabDocField
|
||||
if not frappe.conn.sql("""select name from tabDocField
|
||||
where fieldname = 'amended_from' and parent = %s""", self.doc.name):
|
||||
new = self.doc.addchild('fields', 'DocField', self.doclist)
|
||||
new.label = 'Amended From'
|
||||
|
|
@ -153,12 +153,12 @@ class DocType:
|
|||
new.idx = self.get_max_idx() + 1
|
||||
|
||||
def get_max_idx(self):
|
||||
max_idx = webnotes.conn.sql("""select max(idx) from `tabDocField` where parent = %s""",
|
||||
max_idx = frappe.conn.sql("""select max(idx) from `tabDocField` where parent = %s""",
|
||||
self.doc.name)
|
||||
return max_idx and max_idx[0][0] or 0
|
||||
|
||||
def validate_fields_for_doctype(doctype):
|
||||
from webnotes.model.doctype import get
|
||||
from frappe.model.doctype import get
|
||||
validate_fields(get(doctype, cached=False).get({"parent":doctype,
|
||||
"doctype":"DocField"}))
|
||||
|
||||
|
|
@ -167,33 +167,33 @@ def validate_fields(fields):
|
|||
for c in ['.', ',', ' ', '-', '&', '%', '=', '"', "'", '*', '$',
|
||||
'(', ')', '[', ']', '/']:
|
||||
if c in fieldname:
|
||||
webnotes.msgprint("'%s' not allowed in fieldname (%s)" % (c, fieldname))
|
||||
frappe.msgprint("'%s' not allowed in fieldname (%s)" % (c, fieldname))
|
||||
|
||||
def check_unique_fieldname(fieldname):
|
||||
duplicates = filter(None, map(lambda df: df.fieldname==fieldname and str(df.idx) or None, fields))
|
||||
if len(duplicates) > 1:
|
||||
webnotes.msgprint('Fieldname <b>%s</b> appears more than once in rows (%s). Please rectify' \
|
||||
frappe.msgprint('Fieldname <b>%s</b> appears more than once in rows (%s). Please rectify' \
|
||||
% (fieldname, ', '.join(duplicates)), raise_exception=1)
|
||||
|
||||
def check_illegal_mandatory(d):
|
||||
if d.fieldtype in ('HTML', 'Button', 'Section Break', 'Column Break') and d.reqd:
|
||||
webnotes.msgprint('%(label)s [%(fieldtype)s] cannot be mandatory' % d.fields,
|
||||
frappe.msgprint('%(label)s [%(fieldtype)s] cannot be mandatory' % d.fields,
|
||||
raise_exception=1)
|
||||
|
||||
def check_link_table_options(d):
|
||||
if d.fieldtype in ("Link", "Table"):
|
||||
if not d.options:
|
||||
webnotes.msgprint("""#%(idx)s %(label)s: Options must be specified for Link and Table type fields""" % d.fields,
|
||||
frappe.msgprint("""#%(idx)s %(label)s: Options must be specified for Link and Table type fields""" % d.fields,
|
||||
raise_exception=1)
|
||||
if d.options=="[Select]":
|
||||
return
|
||||
if d.options != d.parent and not webnotes.conn.exists("DocType", d.options):
|
||||
webnotes.msgprint("""#%(idx)s %(label)s: Options %(options)s must be a valid "DocType" for Link and Table type fields""" % d.fields,
|
||||
if d.options != d.parent and not frappe.conn.exists("DocType", d.options):
|
||||
frappe.msgprint("""#%(idx)s %(label)s: Options %(options)s must be a valid "DocType" for Link and Table type fields""" % d.fields,
|
||||
raise_exception=1)
|
||||
|
||||
def check_hidden_and_mandatory(d):
|
||||
if d.hidden and d.reqd and not d.default:
|
||||
webnotes.msgprint("""#%(idx)s %(label)s: Cannot be hidden and mandatory (reqd) without default""" % d.fields,
|
||||
frappe.msgprint("""#%(idx)s %(label)s: Cannot be hidden and mandatory (reqd) without default""" % d.fields,
|
||||
raise_exception=True)
|
||||
|
||||
def check_max_items_in_list(fields):
|
||||
|
|
@ -201,20 +201,20 @@ def validate_fields(fields):
|
|||
for d in fields:
|
||||
if d.in_list_view: count+=1
|
||||
if count > 5:
|
||||
webnotes.msgprint("""Max 5 Fields can be set as 'In List View', please unselect a field before selecting a new one.""")
|
||||
frappe.msgprint("""Max 5 Fields can be set as 'In List View', please unselect a field before selecting a new one.""")
|
||||
|
||||
def check_width(d):
|
||||
if d.fieldtype == "Currency" and cint(d.width) < 100:
|
||||
webnotes.msgprint("Minimum width for FieldType 'Currency' is 100px", raise_exception=1)
|
||||
frappe.msgprint("Minimum width for FieldType 'Currency' is 100px", raise_exception=1)
|
||||
|
||||
def check_in_list_view(d):
|
||||
if d.in_list_view and d.fieldtype!="Image" and (d.fieldtype in no_value_fields):
|
||||
webnotes.msgprint("'In List View' not allowed for field of type '%s'" % d.fieldtype, raise_exception=1)
|
||||
frappe.msgprint("'In List View' not allowed for field of type '%s'" % d.fieldtype, raise_exception=1)
|
||||
|
||||
for d in fields:
|
||||
if not d.permlevel: d.permlevel = 0
|
||||
if not d.fieldname:
|
||||
webnotes.msgprint("Fieldname is mandatory in row %s" % d.idx, raise_exception=1)
|
||||
frappe.msgprint("Fieldname is mandatory in row %s" % d.idx, raise_exception=1)
|
||||
check_illegal_characters(d.fieldname)
|
||||
check_unique_fieldname(d.fieldname)
|
||||
check_illegal_mandatory(d)
|
||||
|
|
@ -223,7 +223,7 @@ def validate_fields(fields):
|
|||
check_in_list_view(d)
|
||||
|
||||
def validate_permissions_for_doctype(doctype, for_remove=False):
|
||||
from webnotes.model.doctype import get
|
||||
from frappe.model.doctype import get
|
||||
validate_permissions(get(doctype, cached=False).get({"parent":doctype,
|
||||
"doctype":"DocPerm"}), for_remove)
|
||||
|
||||
|
|
@ -231,7 +231,7 @@ def validate_permissions(permissions, for_remove=False):
|
|||
doctype = permissions and permissions[0].parent
|
||||
issingle = issubmittable = isimportable = False
|
||||
if doctype and not doctype.startswith("New DocType"):
|
||||
values = webnotes.conn.get_value("DocType", doctype,
|
||||
values = frappe.conn.get_value("DocType", doctype,
|
||||
["issingle", "is_submittable", "allow_import"], as_dict=True)
|
||||
issingle = cint(values.issingle)
|
||||
issubmittable = cint(values.is_submittable)
|
||||
|
|
@ -242,7 +242,7 @@ def validate_permissions(permissions, for_remove=False):
|
|||
|
||||
def check_atleast_one_set(d):
|
||||
if not d.read and not d.write and not d.submit and not d.cancel and not d.create:
|
||||
webnotes.msgprint(get_txt(d) + " Atleast one of Read, Write, Create, Submit, Cancel must be set.",
|
||||
frappe.msgprint(get_txt(d) + " Atleast one of Read, Write, Create, Submit, Cancel must be set.",
|
||||
raise_exception=True)
|
||||
|
||||
def check_double(d):
|
||||
|
|
@ -253,37 +253,37 @@ def validate_permissions(permissions, for_remove=False):
|
|||
})
|
||||
|
||||
if len(similar) > 1:
|
||||
webnotes.msgprint(get_txt(d) + " Only one rule allowed for a particular Role and Level.",
|
||||
frappe.msgprint(get_txt(d) + " Only one rule allowed for a particular Role and Level.",
|
||||
raise_exception=True)
|
||||
|
||||
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.",
|
||||
frappe.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,
|
||||
frappe.msgprint("Create, Submit, Cancel, Amend, Match has no meaning at level " + d.permlevel,
|
||||
raise_exception=True)
|
||||
|
||||
def check_permission_dependency(d):
|
||||
if d.write and not d.read:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Write permission if Read is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Write permission if Read is not set.",
|
||||
raise_exception=True)
|
||||
if d.cancel and not d.submit:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Cancel permission if Submit is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Cancel permission if Submit is not set.",
|
||||
raise_exception=True)
|
||||
if (d.submit or d.cancel or d.amend) and not d.write:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Submit, Cancel, Amend permission if Write is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Submit, Cancel, Amend permission if Write is not set.",
|
||||
raise_exception=True)
|
||||
if d.amend and not d.write:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Amend if Cancel is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Amend if Cancel is not set.",
|
||||
raise_exception=True)
|
||||
if (d.fields.get("import") or d.export) and not d.report:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Import or Export permission if Report is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Import or Export permission if Report is not set.",
|
||||
raise_exception=True)
|
||||
if d.fields.get("import") and not d.create:
|
||||
webnotes.msgprint(get_txt(d) + " Cannot set Import if Create is not set.",
|
||||
frappe.msgprint(get_txt(d) + " Cannot set Import if Create is not set.",
|
||||
raise_exception=True)
|
||||
|
||||
def remove_rights_for_single(d):
|
||||
|
|
@ -291,28 +291,28 @@ def validate_permissions(permissions, for_remove=False):
|
|||
return
|
||||
|
||||
if d.report:
|
||||
webnotes.msgprint("{doctype} {meaningless}".format(doctype=doctype,
|
||||
frappe.msgprint("{doctype} {meaningless}".format(doctype=doctype,
|
||||
meaningless=_("is a single DocType, permission of type Report is meaningless.")))
|
||||
d.report = 0
|
||||
d.fields["import"] = 0
|
||||
d.fields["export"] = 0
|
||||
|
||||
if d.restrict:
|
||||
webnotes.msgprint("{doctype} {meaningless}".format(doctype=doctype,
|
||||
frappe.msgprint("{doctype} {meaningless}".format(doctype=doctype,
|
||||
meaningless=_("is a single DocType, permission of type Restrict is meaningless.")))
|
||||
d.restrict = 0
|
||||
|
||||
def check_if_submittable(d):
|
||||
if d.submit and not issubmittable:
|
||||
webnotes.msgprint(doctype + " is not Submittable, cannot assign submit rights.",
|
||||
frappe.msgprint(doctype + " is not Submittable, cannot assign submit rights.",
|
||||
raise_exception=True)
|
||||
elif d.amend and not issubmittable:
|
||||
webnotes.msgprint(doctype + " is not Submittable, cannot assign amend rights.",
|
||||
frappe.msgprint(doctype + " is not Submittable, cannot assign amend rights.",
|
||||
raise_exception=True)
|
||||
|
||||
def check_if_importable(d):
|
||||
if d.fields.get("import") and not isimportable:
|
||||
webnotes.throw("{doctype}: {not_importable}".format(doctype=doctype,
|
||||
frappe.throw("{doctype}: {not_importable}".format(doctype=doctype,
|
||||
not_importable=_("is not allowed to be imported, cannot assign import rights.")))
|
||||
|
||||
for d in permissions:
|
||||
|
|
@ -329,21 +329,21 @@ def validate_permissions(permissions, for_remove=False):
|
|||
|
||||
def make_module_and_roles(doclist, perm_doctype="DocPerm"):
|
||||
try:
|
||||
if not webnotes.conn.exists("Module Def", doclist[0].module):
|
||||
m = webnotes.bean({"doctype": "Module Def", "module_name": doclist[0].module})
|
||||
if not frappe.conn.exists("Module Def", doclist[0].module):
|
||||
m = frappe.bean({"doctype": "Module Def", "module_name": doclist[0].module})
|
||||
m.insert()
|
||||
|
||||
default_roles = ["Administrator", "Guest", "All"]
|
||||
roles = [p.role for p in doclist.get({"doctype": perm_doctype})] + default_roles
|
||||
|
||||
for role in list(set(roles)):
|
||||
if not webnotes.conn.exists("Role", role):
|
||||
r = webnotes.bean({"doctype": "Role", "role_name": role})
|
||||
if not frappe.conn.exists("Role", role):
|
||||
r = frappe.bean({"doctype": "Role", "role_name": role})
|
||||
r.doc.role_name = role
|
||||
r.insert()
|
||||
except webnotes.DoesNotExistError, e:
|
||||
except frappe.DoesNotExistError, e:
|
||||
pass
|
||||
except webnotes.SQLError, e:
|
||||
except frappe.SQLError, e:
|
||||
if e.args[0]==1146:
|
||||
pass
|
||||
else:
|
||||
|
|
@ -4,7 +4,7 @@
|
|||
# For license information, please see license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,9 +2,9 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
from webnotes.utils import getdate, cint, add_months, date_diff, add_days, nowdate
|
||||
from frappe.utils import getdate, cint, add_months, date_diff, add_days, nowdate
|
||||
|
||||
weekdays = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
|
||||
|
||||
|
|
@ -14,7 +14,7 @@ class DocType:
|
|||
|
||||
def validate(self):
|
||||
if self.doc.starts_on and self.doc.ends_on and self.doc.starts_on > self.doc.ends_on:
|
||||
webnotes.msgprint(webnotes._("Event End must be after Start"), raise_exception=True)
|
||||
frappe.msgprint(frappe._("Event End must be after Start"), raise_exception=True)
|
||||
|
||||
def get_permission_query_conditions():
|
||||
return """(tabEvent.event_type='Public' or tabEvent.owner='%(user)s'
|
||||
|
|
@ -24,24 +24,24 @@ def get_permission_query_conditions():
|
|||
`tabEvent Role`.parent=tabEvent.name
|
||||
and `tabEvent Role`.role in ('%(roles)s')))
|
||||
""" % {
|
||||
"user": webnotes.session.user,
|
||||
"roles": "', '".join(webnotes.get_roles(webnotes.session.user))
|
||||
"user": frappe.session.user,
|
||||
"roles": "', '".join(frappe.get_roles(frappe.session.user))
|
||||
}
|
||||
|
||||
def has_permission(doc):
|
||||
if doc.event_type=="Public" or doc.owner==webnotes.session.user:
|
||||
if doc.event_type=="Public" or doc.owner==frappe.session.user:
|
||||
return True
|
||||
|
||||
# need full doclist to check roles and users
|
||||
bean = webnotes.bean("Event", doc.name)
|
||||
bean = frappe.bean("Event", doc.name)
|
||||
|
||||
if len(bean.doclist)==1:
|
||||
return False
|
||||
|
||||
if bean.doclist.get({"doctype":"Event User", "person":webnotes.session.user}):
|
||||
if bean.doclist.get({"doctype":"Event User", "person":frappe.session.user}):
|
||||
return True
|
||||
|
||||
if bean.doclist.get({"doctype":"Event Role", "role":("in", webnotes.get_roles())}):
|
||||
if bean.doclist.get({"doctype":"Event Role", "role":("in", frappe.get_roles())}):
|
||||
return True
|
||||
|
||||
return False
|
||||
|
|
@ -49,33 +49,33 @@ def has_permission(doc):
|
|||
|
||||
def send_event_digest():
|
||||
today = nowdate()
|
||||
for user in webnotes.conn.sql("""select name, email, language
|
||||
for user in frappe.conn.sql("""select name, email, language
|
||||
from tabProfile where ifnull(enabled,0)=1
|
||||
and user_type='System User' and name not in ('Guest', 'Administrator')""", as_dict=1):
|
||||
events = get_events(today, today, user.name, for_reminder=True)
|
||||
if events:
|
||||
text = ""
|
||||
webnotes.set_user_lang(user.name, user.language)
|
||||
frappe.set_user_lang(user.name, user.language)
|
||||
|
||||
text = "<h3>" + webnotes._("Events In Today's Calendar") + "</h3>"
|
||||
text = "<h3>" + frappe._("Events In Today's Calendar") + "</h3>"
|
||||
for e in events:
|
||||
if e.all_day:
|
||||
e.starts_on = "All Day"
|
||||
text += "<h4>%(starts_on)s: %(subject)s</h4><p>%(description)s</p>" % e
|
||||
|
||||
text += '<p style="color: #888; font-size: 80%; margin-top: 20px; padding-top: 10px; border-top: 1px solid #eee;">'\
|
||||
+ webnotes._("Daily Event Digest is sent for Calendar Events where reminders are set.")+'</p>'
|
||||
+ frappe._("Daily Event Digest is sent for Calendar Events where reminders are set.")+'</p>'
|
||||
|
||||
from webnotes.utils.email_lib import sendmail
|
||||
sendmail(recipients=user.email, subject=webnotes._("Upcoming Events for Today"),
|
||||
from frappe.utils.email_lib import sendmail
|
||||
sendmail(recipients=user.email, subject=frappe._("Upcoming Events for Today"),
|
||||
msg = text)
|
||||
|
||||
@webnotes.whitelist()
|
||||
@frappe.whitelist()
|
||||
def get_events(start, end, user=None, for_reminder=False):
|
||||
if not user:
|
||||
user = webnotes.session.user
|
||||
roles = webnotes.get_roles(user)
|
||||
events = webnotes.conn.sql("""select name, subject, description,
|
||||
user = frappe.session.user
|
||||
roles = frappe.get_roles(user)
|
||||
events = frappe.conn.sql("""select name, subject, description,
|
||||
starts_on, ends_on, owner, all_day, event_type, repeat_this_event, repeat_on,
|
||||
monday, tuesday, wednesday, thursday, friday, saturday, sunday
|
||||
from tabEvent where ((
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
wn.views.calendar["Event"] = {
|
||||
frappe.views.calendar["Event"] = {
|
||||
field_map: {
|
||||
"start": "starts_on",
|
||||
"end": "ends_on",
|
||||
|
|
@ -11,5 +11,5 @@ wn.views.calendar["Event"] = {
|
|||
"Public": "success",
|
||||
"Private": "info"
|
||||
},
|
||||
get_events_method: "webnotes.core.doctype.event.event.get_events"
|
||||
get_events_method: "frappe.core.doctype.event.event.get_events"
|
||||
}
|
||||
|
|
@ -29,36 +29,36 @@ test_records = [
|
|||
|
||||
]
|
||||
|
||||
import webnotes
|
||||
import webnotes.defaults
|
||||
import frappe
|
||||
import frappe.defaults
|
||||
import unittest
|
||||
|
||||
class TestEvent(unittest.TestCase):
|
||||
# def setUp(self):
|
||||
# profile = webnotes.bean("Profile", "test1@example.com")
|
||||
# profile = frappe.bean("Profile", "test1@example.com")
|
||||
# profile.get_controller().add_roles("Website Manager")
|
||||
|
||||
def tearDown(self):
|
||||
webnotes.set_user("Administrator")
|
||||
frappe.set_user("Administrator")
|
||||
|
||||
def test_allowed_public(self):
|
||||
webnotes.set_user("test1@example.com")
|
||||
doc = webnotes.doc("Event", webnotes.conn.get_value("Event", {"subject":"_Test Event 1"}))
|
||||
self.assertTrue(webnotes.has_permission("Event", refdoc=doc))
|
||||
frappe.set_user("test1@example.com")
|
||||
doc = frappe.doc("Event", frappe.conn.get_value("Event", {"subject":"_Test Event 1"}))
|
||||
self.assertTrue(frappe.has_permission("Event", refdoc=doc))
|
||||
|
||||
def test_not_allowed_private(self):
|
||||
webnotes.set_user("test1@example.com")
|
||||
doc = webnotes.doc("Event", webnotes.conn.get_value("Event", {"subject":"_Test Event 2"}))
|
||||
self.assertFalse(webnotes.has_permission("Event", refdoc=doc))
|
||||
frappe.set_user("test1@example.com")
|
||||
doc = frappe.doc("Event", frappe.conn.get_value("Event", {"subject":"_Test Event 2"}))
|
||||
self.assertFalse(frappe.has_permission("Event", refdoc=doc))
|
||||
|
||||
def test_allowed_private_if_in_event_user(self):
|
||||
webnotes.set_user("test1@example.com")
|
||||
doc = webnotes.doc("Event", webnotes.conn.get_value("Event", {"subject":"_Test Event 3"}))
|
||||
self.assertTrue(webnotes.has_permission("Event", refdoc=doc))
|
||||
frappe.set_user("test1@example.com")
|
||||
doc = frappe.doc("Event", frappe.conn.get_value("Event", {"subject":"_Test Event 3"}))
|
||||
self.assertTrue(frappe.has_permission("Event", refdoc=doc))
|
||||
|
||||
def test_event_list(self):
|
||||
webnotes.set_user("test1@example.com")
|
||||
res = webnotes.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"])
|
||||
frappe.set_user("test1@example.com")
|
||||
res = frappe.get_list("Event", filters=[["Event", "subject", "like", "_Test Event%"]], fields=["name", "subject"])
|
||||
self.assertEquals(len(res), 2)
|
||||
subjects = [r.subject for r in res]
|
||||
self.assertTrue("_Test Event 1" in subjects)
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
class DocType:
|
||||
def __init__(self, d, dl):
|
||||
|
|
@ -8,19 +8,19 @@ record of files
|
|||
naming for same name files: file.gif, file-1.gif, file-2.gif etc
|
||||
"""
|
||||
|
||||
import webnotes, webnotes.utils, os
|
||||
from webnotes import conf
|
||||
import frappe, frappe.utils, os
|
||||
from frappe import conf
|
||||
|
||||
class DocType():
|
||||
def __init__(self, d, dl):
|
||||
self.doc, self.doclist = d, dl
|
||||
|
||||
def before_insert(self):
|
||||
webnotes.local.rollback_observers.append(self)
|
||||
frappe.local.rollback_observers.append(self)
|
||||
|
||||
def on_update(self):
|
||||
# check duplicate assignement
|
||||
n_records = webnotes.conn.sql("""select name from `tabFile Data`
|
||||
n_records = frappe.conn.sql("""select name from `tabFile Data`
|
||||
where file_name=%s
|
||||
and name!=%s
|
||||
and attached_to_doctype=%s
|
||||
|
|
@ -28,28 +28,28 @@ class DocType():
|
|||
self.doc.attached_to_name))
|
||||
if len(n_records) > 0:
|
||||
self.doc.duplicate_entry = n_records[0][0]
|
||||
webnotes.msgprint(webnotes._("Same file has already been attached to the record"))
|
||||
webnotes.conn.rollback()
|
||||
raise webnotes.DuplicateEntryError
|
||||
frappe.msgprint(frappe._("Same file has already been attached to the record"))
|
||||
frappe.conn.rollback()
|
||||
raise frappe.DuplicateEntryError
|
||||
|
||||
def on_trash(self):
|
||||
if self.doc.attached_to_name:
|
||||
# check persmission
|
||||
try:
|
||||
if not webnotes.has_permission(self.doc.attached_to_doctype,
|
||||
if not frappe.has_permission(self.doc.attached_to_doctype,
|
||||
"write", self.doc.attached_to_name):
|
||||
webnotes.msgprint(webnotes._("No permission to write / remove."),
|
||||
frappe.msgprint(frappe._("No permission to write / remove."),
|
||||
raise_exception=True)
|
||||
except webnotes.DoesNotExistError:
|
||||
except frappe.DoesNotExistError:
|
||||
pass
|
||||
|
||||
# if file not attached to any other record, delete it
|
||||
if self.doc.file_name and not webnotes.conn.count("File Data",
|
||||
if self.doc.file_name and not frappe.conn.count("File Data",
|
||||
{"file_name": self.doc.file_name, "name": ["!=", self.doc.name]}):
|
||||
if self.doc.file_name.startswith("files/"):
|
||||
path = webnotes.utils.get_site_path("public", self.doc.file_name)
|
||||
path = frappe.utils.get_site_path("public", self.doc.file_name)
|
||||
else:
|
||||
path = webnotes.utils.get_site_path("public", "files", self.doc.file_name)
|
||||
path = frappe.utils.get_site_path("public", "files", self.doc.file_name)
|
||||
if os.path.exists(path):
|
||||
os.remove(path)
|
||||
|
||||
|
|
@ -4,8 +4,8 @@
|
|||
cur_frm.cscript.refresh = function(doc) {
|
||||
cur_frm.set_intro("");
|
||||
if(doc.__islocal) {
|
||||
cur_frm.set_intro(wn._("Step 1: Set the name and save."));
|
||||
cur_frm.set_intro(frappe._("Step 1: Set the name and save."));
|
||||
} else if(!cur_frm.doc.content) {
|
||||
cur_frm.set_intro(wn._("Step 2: Set Letterhead content."));
|
||||
cur_frm.set_intro(frappe._("Step 2: Set Letterhead content."));
|
||||
}
|
||||
}
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# MIT License. See license.txt
|
||||
|
||||
from __future__ import unicode_literals
|
||||
import webnotes
|
||||
import frappe
|
||||
|
||||
|
||||
class DocType:
|
||||
|
|
@ -14,17 +14,17 @@ class DocType:
|
|||
self.set_as_default()
|
||||
|
||||
# clear the cache so that the new letter head is uploaded
|
||||
webnotes.clear_cache()
|
||||
frappe.clear_cache()
|
||||
|
||||
def set_as_default(self):
|
||||
from webnotes.utils import set_default
|
||||
from frappe.utils import set_default
|
||||
if not self.doc.is_default:
|
||||
if not webnotes.conn.sql("""select count(*) from `tabLetter Head` where ifnull(is_default,0)=1"""):
|
||||
if not frappe.conn.sql("""select count(*) from `tabLetter Head` where ifnull(is_default,0)=1"""):
|
||||
self.doc.is_default = 1
|
||||
if self.doc.is_default:
|
||||
webnotes.conn.sql("update `tabLetter Head` set is_default=0 where name != %s",
|
||||
frappe.conn.sql("update `tabLetter Head` set is_default=0 where name != %s",
|
||||
self.doc.name)
|
||||
set_default('letter_head', self.doc.name)
|
||||
|
||||
# update control panel - so it loads new letter directly
|
||||
webnotes.conn.set_value('Control Panel', None, 'letter_head', self.doc.content)
|
||||
frappe.conn.set_value('Control Panel', None, 'letter_head', self.doc.content)
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue