model_wrapper is now bean, refactoring defaults

core/doctype/customize_form/customize_form.py

@@ -144,7 +144,7 @@ class DocType:
 
 	def post(self):
 		"""
-			Save diff between Customize Form ModelWrapper and DocType ModelWrapper as property setter entries
+			Save diff between Customize Form Bean and DocType Bean as property setter entries
 		"""
 		if self.doc.doc_type:
 			from webnotes.model import doc

core/doctype/doctype_mapper/doctype_mapper.py

@@ -26,7 +26,7 @@ import webnotes
 from webnotes.utils import cint, cstr, default_fields, flt
 from webnotes.model import db_exists, default_fields
 from webnotes.model.doc import Document, addchild, make_autoname
-from webnotes.model.wrapper import getlist
+from webnotes.model.bean import getlist
 from webnotes import msgprint
 from webnotes.model.doctype import get
 

core/doctype/workflow/workflow.py

@@ -37,7 +37,7 @@ class DocType:
 			"fieldname":self.doc.workflow_state_field})):
 			
 			# create custom field
-			webnotes.model_wrapper([{
+			webnotes.bean([{
 				"doctype":"Custom Field",
 				"dt": self.doc.document_type,
 				"__islocal": 1,

core/page/data_import_tool/data_import_tool.py

@@ -282,21 +282,21 @@ def delete_child_rows(rows, doctype):
 		
 def import_doc(d, doctype, overwrite, row_idx):
 	"""import main (non child) document"""
-	from webnotes.model.wrapper import ModelWrapper
+	from webnotes.model.bean import Bean
 
 	if webnotes.conn.exists(doctype, d['name']):
 		if overwrite:
 			doclist = webnotes.model.doc.get(doctype, d['name'])
 			doclist[0].fields.update(d)
-			model_wrapper = ModelWrapper(doclist)
-			model_wrapper.save()
+			bean = Bean(doclist)
+			bean.save()
 			return 'Updated row (#%d) %s' % (row_idx, getlink(doctype, d['name']))
 		else:
 			return 'Ignored row (#%d) %s (exists)' % (row_idx, 
 				getlink(doctype, d['name']))
 	else:
 		d['__islocal'] = 1
-		dl = ModelWrapper([webnotes.model.doc.Document(fielddata = d)])
+		dl = Bean([webnotes.model.doc.Document(fielddata = d)])
 		dl.save()
 		return 'Inserted row (#%d) %s' % (row_idx, getlink(doctype,
 			dl.doc.fields['name']))

core/page/user_properties/user_properties.py

@@ -1,5 +1,6 @@
 from __future__ import unicode_literals
 import webnotes
+import webnotes.defaults
 
 @webnotes.whitelist(allow_roles=["System Manager", "Administrator"])
 def get_users_and_links():
@@ -41,7 +42,8 @@ def get_properties(user=None, key=None):
 def remove(user, name):
 	webnotes.conn.sql("""delete from tabDefaultValue where name=%s""", name)
 	webnotes.clear_cache(user=user)
+	webnotes.defaults(user=user)
 	
 @webnotes.whitelist(allow_roles=["System Manager", "Administrator"])
 def add(parent, defkey, defvalue):
-	webnotes.conn.add_default(defkey, defvalue, parent)
+	webnotes.defaults.add_user_default(defkey, defvalue, parent)

webnotes/__init__.py

@@ -312,12 +312,15 @@ def doclist(lst=None):
 	from webnotes.model.doclist import DocList
 	return DocList(lst)
 
-def model_wrapper(doctype=None, name=None):
-	from webnotes.model.wrapper import ModelWrapper
-	return ModelWrapper(doctype, name)
+def bean(doctype=None, name=None, copy=None):
+	from webnotes.model.bean import Bean
+	if copy:
+		return Bean(copy_doclist(copy))
+	else:
+		return Bean(doctype, name)
 
 def get_doclist(doctype, name=None):
-	return model_wrapper(doctype, name).doclist
+	return bean(doctype, name).doclist
 	
 def get_doctype(doctype, processed=False):
 	import webnotes.model.doctype
@@ -357,7 +360,7 @@ def get_method(method_string):
 	
 def make_property_setter(args):
 	args = _dict(args)
-	model_wrapper([{
+	bean([{
 		'doctype': "Property Setter",
 		'doctype_or_field': args.doctype_or_field or "DocField",
 		'doc_type': args.doctype,

webnotes/client.py

@@ -30,7 +30,7 @@ def get(doctype, name=None, filters=None):
 		name = webnotes.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.model_wrapper(doctype, name).doclist]
+	return [d.fields for d in webnotes.bean(doctype, name).doclist]
 	
 @webnotes.whitelist()
 def insert(doclist):
@@ -45,7 +45,7 @@ def save(doclist):
 	if isinstance(doclist, basestring):
 		doclist = json.loads(doclist)
 
-	doclistobj = webnotes.model_wrapper(doclist)
+	doclistobj = webnotes.bean(doclist)
 	doclistobj.save()
 	
 	return [d.fields for d in doclist]
@@ -55,14 +55,14 @@ def submit(doclist):
 	if isinstance(doclist, basestring):
 		doclist = json.loads(doclist)
 
-	doclistobj = webnotes.model_wrapper(doclist)
+	doclistobj = webnotes.bean(doclist)
 	doclistobj.submit()
 	
 	return [d.fields for d in doclist]
 
 @webnotes.whitelist()
 def cancel(doctype, name):
-	wrapper = webnotes.model_wrapper(doctype, name)
+	wrapper = webnotes.bean(doctype, name)
 	wrapper.cancel()
 	
 	return [d.fields for d in wrapper.doclist]
@@ -77,4 +77,4 @@ def set_default(key, value, parent=None):
 def make_width_property_setter():
 	doclist = json.loads(webnotes.form_dict.doclist)
 	if doclist[0]["doctype"]=="Property Setter" and doclist[0]["property"]=="width":
-		webnotes.model_wrapper(doclist).save()
+		webnotes.bean(doclist).save()

webnotes/db.py

@@ -299,15 +299,10 @@ class Database:
 		doc.fields[field] = val
 
 	def set_global(self, key, val, user='__global'):
-		res = self.sql('select defkey from `tabDefaultValue` where defkey=%s and parent=%s', (key, user))
-		if res:
-			self.sql('update `tabDefaultValue` set defvalue=%s where parent=%s and defkey=%s', (str(val), user, key))
-		else:
-			self.sql('insert into `tabDefaultValue` (name, defkey, defvalue, parent) values (%s,%s,%s,%s)', (user+'_'+key, key, str(val), user))
+		self.set_default(key, val, user)
 
 	def get_global(self, key, user='__global'):
-		g = self.sql("select defvalue from tabDefaultValue where defkey=%s and parent=%s", (key, user))
-		return g and g[0][0] or None
+		return self.get_default(key, val, user)
 		
 	def get_globals_like(self, key):
 		return [g[0] for g in self.sql("""select defvalue from tabDefaultValue 
@@ -315,56 +310,31 @@ class Database:
 
 	def set_default(self, key, val, parent="Control Panel"):
 		"""set control panel default (tabDefaultVal)"""
-
-		if self.sql("""select defkey from `tabDefaultValue` where 
-			defkey=%s and parent=%s """, (key, parent)):
-			# update
-			self.sql("""update `tabDefaultValue` set defvalue=%s 
-				where parent=%s and defkey=%s""", (val, parent, key))
-			webnotes.clear_cache()
-		else:
-			self.add_default(key, val, parent)
+		import webnotes.defaults
+		webnotes.defaults.set_default(key, val, parent)
 			
 	def add_default(self, key, val, parent="Control Panel"):
-		d = webnotes.doc('DefaultValue')
-		d.parent = parent
-		d.parenttype = 'Control Panel' # does not matter
-		d.parentfield = 'system_defaults'
-		d.defkey = key
-		d.defvalue = val
-		d.save(1)
-		webnotes.clear_cache()
+		import webnotes.defaults
+		webnotes.defaults.add_default(key, val, parent)
 	
 	def get_default(self, key, parent="Control Panel"):
 		"""get default value"""
-		ret = self.get_defaults_as_list(key, parent)
-		return ret and ret[0] or None
+		import webnotes.defaults
+		d = webnotes.defaults.get_default(key, val, parent)
+		return isinstance(d, list) and d[0] or d
 		
 	def get_defaults_as_list(self, key, parent="Control Panel"):
-		ret = [r[0] for r in self.sql("""select defvalue from \
-			tabDefaultValue where defkey=%s and parent=%s""", (key, parent))]
-		if key in ["owner", "user"] and webnotes.session:
-			ret.append(webnotes.session.user)
-		return ret
+		import webnotes.defaults
+		d = webnotes.defaults.get_default(key, val, parent)
+		return isinstance(d, basestring) and [d] or d
 	
 	def get_defaults(self, key=None, parent="Control Panel"):
 		"""get all defaults"""
+		import webnotes.defaults
 		if key:
-			return self.get_default(key, parent)
+			return webnotes.defaults.get_defaults(parent).get(key)
 		else:
-			res = self.sql("""select defkey, defvalue from `tabDefaultValue` 
-				where parent = %s""", parent, as_dict=1)
-			defaults = webnotes._dict({})
-			for d in res:
-				if d.defkey in defaults:
-					# listify
-					if isinstance(defaults[d.defkey], basestring):
-						defaults[d.defkey] = [defaults[d.defkey]]
-					defaults[d.defkey].append(d.defvalue)
-				else:		
-					defaults[d.defkey] = d.defvalue
-
-			return defaults
+			return webnotes.defaults.get_defaults(parent)
 
 	def begin(self):
 		return # not required

webnotes/defaults.py

@@ -0,0 +1,107 @@
+from __future__ import unicode_literals
+import webnotes
+import memc
+
+# User
+
+def set_user_default(key, value, user=None):
+	set_default(key, value, user or webnotes.session.user)
+
+def add_user_default(key, value, user=None):
+	add_default(key, value, user or webnotes.session.user)
+
+def get_user_default(key, user=None):
+	d = get_defaults(user or webnotes.session.user).get(key, None)
+	if d is None:
+		d = get_global_default(key)
+	return isinstance(d, list) and d[0] or d
+
+def get_user_defaults(key, user=None):
+	d = get_defaults(user or webnotes.session.user).get(key, None)
+	if d is None:
+		d = get_global_defaults(key)
+	return isinstance(d, basestring) and [d] or d
+	
+def get_all_user_defaults(user=None):
+	userd = get_defaults(user or webnotes.session.user)
+	globald = get_defaults()
+	
+	globald.update(userd)
+	return globald
+
+def clear_user_default(key, user=None):
+	clear_default(key, user or webnotes.session.user)
+
+# Global
+
+def set_global_default(key, value):
+	set_default(key, value, "Control Panel")
+
+def add_global_default(key, value):
+	add_default(key, value, "Control Panel")
+
+def get_global_default(key):
+	d = get_defaults().get(key, None)
+	return isinstance(d, list) and d[0] or d
+	
+def get_global_defaults(key):
+	d = get_defaults().get(key, None)
+	return isinstance(d, basestring) and [d] or d
+	
+# Common
+
+def set_default(key, value, parent):
+	if webnotes.conn.sql("""select defkey from `tabDefaultValue` where 
+		defkey=%s and parent=%s """, (key, parent)):
+		# update
+		webnotes.conn.sql("""update `tabDefaultValue` set defvalue=%s 
+			where parent=%s and defkey=%s""", (value, parent, key))
+		clear_cache(parent)
+	else:
+		add_default(key, value, parent)
+
+def add_default(key, value, parent):
+	d = webnotes.doc({
+		"doctype": "DefaultValue",
+		"parent": parent,
+		"parenttype": "Control Panel",
+		"parentfield": "system_defaults",
+		"defkey": key,
+		"defvalue": value
+	})
+	d.insert()
+	clear_cache(parent)
+	
+def clear_default(key, parent="Control Panel"):
+	webnotes.conn.sql("""delete from tabDefaultValue where defkey=%s and parent=%s""", (key, parent))
+	clear_cache(parent)
+	
+def get_defaults(parent="Control Panel"):
+	"""get all defaults"""
+	defaults = webnotes.cache().get_value("__defaults:" + parent)
+	if not defaults:
+		if parent=="Control Panel":
+			res = webnotes.conn.sql("""select defkey, defvalue from `tabDefaultValue` 
+				where parent = %s order by creation""", parent, as_dict=1)
+		else:
+			roles = webnotes.get_roles()
+			res = webnotes.conn.sql("""select defkey, defvalue from `tabDefaultValue` 
+				where parent in ('%s') order by creation""" % ("', '".join(roles)), as_dict=1)
+
+		defaults = webnotes._dict({})
+		for d in res:
+			if d.defkey in defaults:
+				# listify
+				if isinstance(defaults[d.defkey], basestring):
+					defaults[d.defkey] = [defaults[d.defkey]]
+				defaults[d.defkey].append(d.defvalue)
+			else:
+				defaults[d.defkey] = d.defvalue
+
+		webnotes.cache().set_value("__defaults:" + parent, defaults)
+	
+	return defaults
+
+def clear_cache(parent):
+	webnotes.cache().delete_value("__defaults:" + parent)
+	webnotes.clear_cache()

webnotes/handler.py

@@ -73,7 +73,7 @@ def dt_map():
 	import webnotes.model.utils
 	from webnotes.model.code import get_obj
 	from webnotes.model.doc import Document
-	from webnotes.model.wrapper import ModelWrapper
+	from webnotes.model.bean import Bean
 	
 	form_dict = webnotes.form_dict
 	
@@ -84,7 +84,7 @@ def dt_map():
 	from_to_list = form_dict.get('from_to_list')
 	
 	dm = get_obj('DocType Mapper', from_doctype +'-' + to_doctype)
-	dl = dm.dt_map(from_doctype, to_doctype, from_docname, Document(fielddata = dt_list[0]), (len(dt_list) > 1) and ModelWrapper(dt_list).doclist or [], from_to_list)
+	dl = dm.dt_map(from_doctype, to_doctype, from_docname, Document(fielddata = dt_list[0]), (len(dt_list) > 1) and Bean(dt_list).doclist or [], from_to_list)
 	
 	webnotes.response['docs'] = dl
 

webnotes/model/__init__.py

@@ -37,7 +37,7 @@ def insert(doclist):
 		else:
 			d.fields["__islocal"] = 1
 		
-	wrapper = webnotes.model_wrapper(doclist)
+	wrapper = webnotes.bean(doclist)
 	wrapper.save()
 	
 	return wrapper

webnotes/model/wrapper.py → webnotes/model/bean.py

@@ -22,7 +22,7 @@
 
 from __future__ import unicode_literals
 """
-Transactions are defined as collection of classes, a ModelWrapper represents collection of Document
+Transactions are defined as collection of classes, a Bean represents collection of Document
 objects for a transaction with main and children.
 
 Group actions like save, etc are performed on doclists
@@ -33,7 +33,7 @@ from webnotes import _
 from webnotes.utils import cint
 from webnotes.model.doc import Document
 
-class ModelWrapper:
+class Bean:
 	"""
 	Collection of Documents with one parent and multiple children
 	"""
@@ -306,9 +306,9 @@ class ModelWrapper:
 def clone(source_wrapper):
 	""" Copy previous invoice and change dates"""
 	if isinstance(source_wrapper, list):
-		source_wrapper = ModelWrapper(source_wrapper)
+		source_wrapper = Bean(source_wrapper)
 	
-	new_wrapper = ModelWrapper(source_wrapper.doclist.copy())
+	new_wrapper = Bean(source_wrapper.doclist.copy())
 	new_wrapper.doc.fields.update({
 		"amended_from": None,
 		"amendment_date": None,

webnotes/model/code.py

@@ -32,7 +32,7 @@ methods in following modules are imported for backward compatibility
 	* webnotes.*
 	* webnotes.utils.*
 	* webnotes.model.doc.*
-	* webnotes.model.wrapper.*
+	* webnotes.model.bean.*
 """
 custom_class = '''
 import webnotes

webnotes/model/sync.py

@@ -60,7 +60,7 @@ def sync_doctype(module_name, docname, force=0):
 def merge_doctype(doclist, force=False):
 	modified = doclist[0]['modified']
 	if not doclist:
-		raise Exception('ModelWrapper could not be evaluated')
+		raise Exception('Bean could not be evaluated')
 
 	db_modified = str(webnotes.conn.get_value(doclist[0].get('doctype'),
 		doclist[0].get('name'), 'modified'))

webnotes/profile.py

@@ -208,7 +208,7 @@ def get_system_managers():
 	return [p[0] for p in system_managers]
 	
 def add_role(profile, role):
-	profile_wrapper = webnotes.model_wrapper("Profile", profile)
+	profile_wrapper = webnotes.bean("Profile", profile)
 	profile_wrapper.doclist.append({
 		"doctype": "UserRole",
 		"parentfield": "user_roles",

webnotes/sessions.py

@@ -53,7 +53,7 @@ def clear_cache(user=None):
 		for sess in webnotes.conn.sql("""select user, sid from tabSessions""", as_dict=1):
 			cache.delete_value("sesssion:" + sess.sid)
 			cache.delete_value("bootinfo:" + sess.user)
-	
+
 def clear_sessions(user=None, keep_current=False):
 	if not user:
 		user = webnotes.session.user

webnotes/test_runner.py

@@ -69,7 +69,7 @@ def make_test_objects(doctype, test_records):
 	for doclist in test_records:
 		if not "doctype" in doclist[0]:
 			doclist[0]["doctype"] = doctype
-		d = webnotes.model_wrapper((webnotes.doclist(doclist)).copy())
+		d = webnotes.bean((webnotes.doclist(doclist)).copy())
 		if webnotes.test_objects.get(d.doc.doctype):
 			# do not create test records, if already exists
 			return []
@@ -100,7 +100,7 @@ def export_doc(doctype, docname):
 	make_test_records(doctype)
 	meta = webnotes.get_doctype(doctype)
 	
-	for d in webnotes.model_wrapper(doctype, docname):
+	for d in webnotes.bean(doctype, docname):
 		new_doc = {}
 		for key, val in d.fields.iteritems():
 			if val and key not in ignore_list:
@@ -157,6 +157,7 @@ if __name__=="__main__":
 	parser.add_argument('-v', '--verbose', default=False, action="store_true")
 	parser.add_argument('-e', '--export', nargs=2, metavar="DOCTYPE DOCNAME")
 	parser.add_argument('-a', '--all', default=False, action="store_true")
+	parser.add_argument('-m', '--module', default=1, metavar="MODULE")
 
 	args = parser.parse_args()
 	webnotes.print_messages = args.verbose
@@ -170,5 +171,10 @@ if __name__=="__main__":
 		run_all_tests(args.verbose)
 	elif args.export:
 		export_doc(args.export[0], args.export[1])
+	elif args.module:
+		test_suite = unittest.TestSuite()
+		__import__(args.module)
+		test_suite.addTest(unittest.TestLoader().loadTestsFromModule(sys.modules[args.module]))
+		unittest.TextTestRunner(verbosity=1+(args.verbose and 1 or 0)).run(test_suite)
 	
 	

webnotes/tests/test_defaults.py

@@ -0,0 +1,37 @@
+import webnotes, unittest
+
+from webnotes.defaults import *
+
+class TestDefaults(unittest.TestCase):
+	def test_global(self):
+		set_global_default("key1", "value1")
+		self.assertEquals(get_global_default("key1"), "value1")
+
+		set_global_default("key1", "value2")
+		self.assertEquals(get_global_default("key1"), "value2")
+
+		add_global_default("key1", "value3")
+		self.assertEquals(get_global_default("key1"), "value2")
+		self.assertEquals(get_global_defaults("key1"), ["value2", "value3"])
+
+	def test_user(self):
+		set_user_default("key1", "2value1")
+		self.assertEquals(get_user_default("key1"), "2value1")
+
+		set_user_default("key1", "2value2")
+		self.assertEquals(get_user_default("key1"), "2value2")
+
+		add_user_default("key1", "3value3")
+		self.assertEquals(get_user_default("key1"), "2value2")
+		self.assertEquals(get_user_defaults("key1"), ["2value2", "3value3"])
+		
+	def test_global_if_not_user(self):
+		set_global_default("key4", "value4")
+		self.assertEquals(get_user_default("key4"), "value4")
+
+	def test_clear(self):
+		set_user_default("key5", "value5")
+		self.assertEquals(get_user_default("key5"), "value5")
+		clear_user_default("key5")
+		self.assertEquals(get_user_default("key5"), None)
+		

webnotes/translate.py

@@ -109,7 +109,7 @@ def build_for_doc_from_database(fields):
 
 	for item in webnotes.conn.sql("""select name from `tab%s`""" % fields.doctype, as_dict=1):
 		messages = []
-		doclist = webnotes.model_wrapper(fields.doctype, item.name).doclist
+		doclist = webnotes.bean(fields.doctype, item.name).doclist
 
 		for doc in doclist:
 			if doc.doctype in fields:

webnotes/utils/nestedset.py

@@ -33,7 +33,7 @@ from __future__ import unicode_literals
 
 import webnotes, unittest
 from webnotes import msgprint
-from webnotes.model.wrapper import ModelWrapper
+from webnotes.model.bean import Bean
 from webnotes.model.doc import Document
 
 class TestNSM(unittest.TestCase):
@@ -53,7 +53,7 @@ class TestNSM(unittest.TestCase):
 		]
 		
 		for d in self.data:
-			self.__dict__[d[0]] = ModelWrapper([Document(fielddata = {
+			self.__dict__[d[0]] = Bean([Document(fielddata = {
 				"doctype": "Item Group", "item_group_name": d[0], "parent_item_group": d[1],
 				"__islocal": 1
 			})])

webnotes/widgets/calendar.py

@@ -30,7 +30,7 @@ def update_event(args, field_map):
 	args = webnotes._dict(json.loads(args))
 	field_map = webnotes._dict(json.loads(field_map))
 			
-	w = webnotes.model_wrapper(args.doctype, args.name)
+	w = webnotes.bean(args.doctype, args.name)
 	w.doc.fields[field_map.start] = args[field_map.start]
 	w.doc.fields[field_map.end] = args[field_map.end]
 	w.save()

webnotes/widgets/form/load.py

@@ -92,7 +92,7 @@ def load_single_doc(dt, dn, user):
 		return None
 
 	try:
-		dl = webnotes.model_wrapper(dt, dn).doclist
+		dl = webnotes.bean(dt, dn).doclist
 	except Exception, e:
 		webnotes.errprint(webnotes.utils.getTraceback())
 		webnotes.msgprint('Error in script while loading')

webnotes/widgets/form/run_method.py

@@ -30,7 +30,7 @@ def runserverobj():
 		Run server objects
 	"""
 	import webnotes.model.code
-	from webnotes.model.wrapper import ModelWrapper
+	from webnotes.model.bean import Bean
 	from webnotes.utils import cint
 
 	wrapper = None
@@ -44,7 +44,7 @@ def runserverobj():
 		so = webnotes.model.code.get_obj(dt, dn)
 
 	else:
-		wrapper = ModelWrapper()
+		wrapper = Bean()
 		wrapper.from_compressed(webnotes.form_dict.get('docs'), dn)
 		if not wrapper.has_read_perm():
 			webnotes.msgprint(_("No Permission"), raise_exception = True)

webnotes/widgets/form/save.py

@@ -27,7 +27,7 @@ import webnotes
 def savedocs():
 	"""save / submit / update doclist"""
 	try:
-		wrapper = webnotes.model_wrapper()
+		wrapper = webnotes.bean()
 		wrapper.from_compressed(webnotes.form_dict.docs, webnotes.form_dict.docname)
 
 		# action
@@ -48,7 +48,7 @@ def savedocs():
 def cancel(doctype=None, name=None):
 	"""cancel a doclist"""
 	try:
-		wrapper = webnotes.model_wrapper(doctype, name)
+		wrapper = webnotes.bean(doctype, name)
 		wrapper.cancel()
 		send_updated_docs(wrapper)
 		

webnotes/widgets/reportview.py

@@ -243,7 +243,7 @@ def save_report():
 		d.ref_doctype = data['doctype']
 		
 	d.json = data['json']
-	webnotes.model_wrapper([d]).save()
+	webnotes.bean([d]).save()
 	webnotes.msgprint("%s saved." % d.name)
 	return d.name