[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
r5065 - in trunk/gnue-appserver/src: . classrep language
|
From: |
johannes |
|
Subject: |
r5065 - in trunk/gnue-appserver/src: . classrep language |
|
Date: |
Wed, 4 Feb 2004 10:04:25 -0600 (CST) |
Author: johannes
Date: 2004-02-04 10:04:22 -0600 (Wed, 04 Feb 2004)
New Revision: 5065
Added:
trunk/gnue-appserver/src/language/Exceptions.py
Modified:
trunk/gnue-appserver/src/classrep/Base.py
trunk/gnue-appserver/src/classrep/Class.py
trunk/gnue-appserver/src/classrep/Module.py
trunk/gnue-appserver/src/classrep/Procedure.py
trunk/gnue-appserver/src/classrep/Property.py
trunk/gnue-appserver/src/classrep/__init__.py
trunk/gnue-appserver/src/classrep/test.py
trunk/gnue-appserver/src/geasInstance.py
trunk/gnue-appserver/src/language/Object.py
trunk/gnue-appserver/src/language/ObjectList.py
trunk/gnue-appserver/src/language/Procedure.py
trunk/gnue-appserver/src/language/Session.py
trunk/gnue-appserver/src/language/test.py
trunk/gnue-appserver/src/test.py
Log:
Removed caching-stuff from language interface and changed the constructors
of language interface and classrepository to use language/Session instead of
sessionManager and sessionId. Made sure to use proper 'underlining' for
private/protected and public identifiers.
Modified: trunk/gnue-appserver/src/classrep/Base.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Base.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/classrep/Base.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -43,10 +43,10 @@
# Reload the dictionary from the database by merging new records in
# ---------------------------------------------------------------------------
def reload (self):
- list = self._session.find (self.table, self._getReloadCondition (),
- self._getSortorder (),
- self._getColumns ())
- self.mergeIntoList (list)
+ rlist = self._session.find (self.table, self._getReloadCondition (),
+ self._getSortorder (),
+ self._getColumns ())
+ self.mergeIntoList (rlist)
# ---------------------------------------------------------------------------
# Merge a given object list with the dictionaries list
@@ -93,7 +93,7 @@
# Use _getNewItem in derived classes to instanciate new dictionary-items
# ---------------------------------------------------------------------------
def _getNewItem (self, obj):
- raise EClassRepository ("%s: getNewItem() not implemented!" % self.table)
+ raise EClassRepository ("%s: _getNewItem() not implemented!" % self.table)
# ---------------------------------------------------------------------------
# Return all keys
@@ -154,10 +154,11 @@
# ---------------------------------------------------------------------------
# Constructor
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, classname, object = None, pDefs = None):
+ def __init__ (self, session, classname, aObject = None, pDefs = None):
self.classname = classname
- self._sm = sessionManager
- self.__object = object
+ self._session = session
+
+ self.__object = aObject
self.__predefined = {}
if pDefs is not None:
@@ -186,6 +187,6 @@
# ---------------------------------------------------------------------------
def __getObject (self):
if self.__object is None:
- self.__object = Object (self._sm, 0, self.classname, self.gnue_id)
- else:
- return self.__object
+ self.__object = Object (self._session, self.classname, self.gnue_id)
+
+ return self.__object
Modified: trunk/gnue-appserver/src/classrep/Class.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Class.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/classrep/Class.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -35,12 +35,10 @@
# ---------------------------------------------------------------------------
# Create a dictionary with all classes [from a specified module]
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, moduleDict, module = None,
- predefines = None):
+ def __init__ (self, session, moduleDict, module = None, predefines = None):
BaseDictionary.__init__ (self, session, 'gnue_class')
self.modules = moduleDict
- self._sm = sessionManager
self.__module = module
# Note: this 'predefines' is a RepositoryDefinition
@@ -49,7 +47,7 @@
cMod = self.modules.find (cDict ['gnue_module'])
proplist = predefines.properties (cDict ['gnue_id'])
- aClass = Class (self._sm, session, self, cMod, None, cDict, proplist)
+ aClass = Class (session, self, cMod, None, cDict, proplist)
self._items [aClass.fullName] = aClass
# if this class dictionary is for a special module, we populate it with
@@ -64,6 +62,7 @@
# fetch a fresh copy from the datasource
self.reload ()
+
# ---------------------------------------------------------------------------
# Reload the dictionary and run nested reloads for all classes
# ---------------------------------------------------------------------------
@@ -74,13 +73,15 @@
aClass.properties.reload ()
aClass.procedures.reload ()
+
# ---------------------------------------------------------------------------
# Create a new instance for a dictionary-item
# ---------------------------------------------------------------------------
def _getNewItem (self, object):
module = self.modules.find (object.gnue_module)
- return Class (self._sm, self._session, self, module, object)
+ return Class (self._session, self, module, object)
+
# ---------------------------------------------------------------------------
# Get an apropriate reload ()-condition
# ---------------------------------------------------------------------------
@@ -91,6 +92,7 @@
else:
return []
+
# ---------------------------------------------------------------------------
# Create a condition to retrieve the klass specified by 'key'
# ---------------------------------------------------------------------------
@@ -101,6 +103,7 @@
return [["eq", ""], ["field", "gnue_module"], ["const", module.gnue_id],
["eq", ""], ["field", "gnue_name"], ["const", className]]
+
# ---------------------------------------------------------------------------
# On find () this dictionary will prepare the following columns ()
# ---------------------------------------------------------------------------
@@ -117,18 +120,17 @@
# ---------------------------------------------------------------------------
# Wrapping a business object class
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, classDict, module, object,
- predefs = None, propDefList = None):
- BaseObject.__init__ (self, sessionManager, 'gnue_class', object, predefs)
+ def __init__ (self, session, classDict, module, object, predefs = None,
+ propDefList = None):
+ BaseObject.__init__ (self, session, 'gnue_class', object, predefs)
self.module = module
self.fullName = createName (module.gnue_name, self.gnue_name)
self.table = self.fullName
self.classes = classDict
- self._session = session
- self.properties = PropertyDict (self._sm, session, self, propDefList)
- self.procedures = ProcedureDict (self._sm, session, self)
+ self.properties = PropertyDict (session, self, propDefList)
+ self.procedures = ProcedureDict (session, self)
# ---------------------------------------------------------------------------
Modified: trunk/gnue-appserver/src/classrep/Module.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Module.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/classrep/Module.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -36,22 +36,20 @@
# This class behaves like a dictionary of all available modules with the
# keys being the module names and the values being Module objects.
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, predefines = None):
+ def __init__ (self, session, predefines = None):
BaseDictionary.__init__ (self, session, 'gnue_module')
- self._sm = sessionManager
-
# Note: this 'predefines' is a RepositoryDefinition
if predefines is not None:
for mDict in predefines.modules ():
- module = Module (self._sm, self._session, self, None, mDict)
+ module = Module (self._session, self, None, mDict)
self._items [module.fullName] = module
# ---------------------------------------------------------------------------
# Create a new module instance
# ---------------------------------------------------------------------------
- def _getNewItem (self, object):
- return Module (self._sm, self._session, self, object)
+ def _getNewItem (self, aObject):
+ return Module (self._session, self, aObject)
# ---------------------------------------------------------------------------
# Create a condition to reload a single module
@@ -77,23 +75,23 @@
# ---------------------------------------------------------------------------
# Constructor
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, mDict, object=None, pDefs=None):
- BaseObject.__init__ (self, sessionManager, 'gnue_module', object, pDefs)
+ def __init__ (self, session, mDict, aObject = None, pDefs = None):
+ BaseObject.__init__ (self, session, 'gnue_module', aObject, pDefs)
self.modules = mDict
self.fullName = self.gnue_name
- self._session = session
# ---------------------------------------------------------------------------
# Return an attribute's value
# ---------------------------------------------------------------------------
def __getattr__ (self, attr):
if attr == 'classes':
- self.__dict__ ['classes'] = ClassDict (self._sm, self._session,
- self.modules, self)
+ self.__dict__ ['classes'] = ClassDict (self._session, self.modules, self)
+
# Make sure the created class-dictionary is up to date
self.classes.reload ()
return self.classes
+
else:
return BaseObject.__getattr__ (self, attr)
Modified: trunk/gnue-appserver/src/classrep/Procedure.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Procedure.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/classrep/Procedure.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -31,22 +31,23 @@
class ProcedureDict (BaseDictionary):
# ---------------------------------------------------------------------------
- # Construct a Procedure-Dictionary for class klass
+ # Construct a Procedure-Dictionary for class aClass
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, klass, predefs = None):
+ def __init__ (self, session, aClass, predefs = None):
BaseDictionary.__init__ (self, session, 'gnue_procedure')
- self._sm = sessionManager
- self.__class = klass
+ self.__class = aClass
self.__module = self.__class.module
+
# ---------------------------------------------------------------------------
# Create a new instance of a dictionary item
# ---------------------------------------------------------------------------
def _getNewItem (self, object):
pMod = self.__module.modules.find (object.gnue_module)
- return Procedure (self._sm, pMod, object)
+ return Procedure (self._session, pMod, object)
+
# ---------------------------------------------------------------------------
# A reload () returns only the procedures of the class
# ---------------------------------------------------------------------------
@@ -54,6 +55,7 @@
return [["eq", ""], ["field", "gnue_class"],
["const", self.__class.gnue_id]]
+
# ---------------------------------------------------------------------------
# Get a condition to match a given procedure
# ---------------------------------------------------------------------------
@@ -64,6 +66,7 @@
["const", self.__class.gnue_id],
["eq", ""], ["field", "gnue_name"], ["const", procName]]
+
# ---------------------------------------------------------------------------
# Get a list of columns to be prepared on a find ()
# ---------------------------------------------------------------------------
@@ -71,6 +74,7 @@
return ["gnue_module", "gnue_class", "gnue_name", "gnue_language"]
+
# =============================================================================
# A Business Object Procedure
# =============================================================================
@@ -79,8 +83,8 @@
# ---------------------------------------------------------------------------
# Construct a new procedure from module, class and business object
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, module, object, pDefs = None):
- BaseObject.__init__ (self, sessionManager, 'gnue_procedure', object, pDefs)
+ def __init__ (self, session, module, object, pDefs = None):
+ BaseObject.__init__ (self, session, 'gnue_procedure', object, pDefs)
# gnue_procedure.gnue_name is already a fully qualified identifier
self.fullName = createName (module.gnue_name, self.gnue_name)
Modified: trunk/gnue-appserver/src/classrep/Property.py
===================================================================
--- trunk/gnue-appserver/src/classrep/Property.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/classrep/Property.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -31,30 +31,31 @@
class PropertyDict (BaseDictionary):
# ---------------------------------------------------------------------------
- # Construct a Property-Dictionary for class klass
+ # Construct a Property-Dictionary for class aClass
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, session, klass, predefs = None):
+ def __init__ (self, session, aClass, predefs = None):
BaseDictionary.__init__ (self, session, 'gnue_property')
- self._sm = sessionManager
- self.__class = klass
+ self.__class = aClass
self.__module = self.__class.module
# predefs is a list of dictionaries, describing the properties
if predefs is not None:
for pDef in predefs:
pMod = self.__module.modules.find (pDef ['gnue_module'])
- prop = Property (self._sm, pMod, None, pDef)
+ prop = Property (session, pMod, None, pDef)
self._items [prop.fullName] = prop
+
# ---------------------------------------------------------------------------
# Create a new instance of a dictionary item
# ---------------------------------------------------------------------------
def _getNewItem (self, object):
pMod = self.__module.modules.find (object.gnue_module)
- return Property (self._sm, pMod, object)
+ return Property (self._session, pMod, object)
+
# ---------------------------------------------------------------------------
# Restrict a reload () to the classes properties
# ---------------------------------------------------------------------------
@@ -62,6 +63,7 @@
return [["eq", ""], ["field", "gnue_class"],
["const", self.__class.gnue_id]]
+
# ---------------------------------------------------------------------------
# Return a condition to match a given Property
# ---------------------------------------------------------------------------
@@ -70,6 +72,7 @@
["const", self.__class.gnue_id],
["eq", ""], ["field", "gnue_name"], ["const", key]]
+
# ---------------------------------------------------------------------------
# Return a list of columns to be prepared by a find ()
# ---------------------------------------------------------------------------
@@ -78,6 +81,7 @@
"gnue_length", "gnue_scale", "gnue_comment"]
+
# =============================================================================
# A Business Object Property
# =============================================================================
@@ -86,9 +90,8 @@
# ---------------------------------------------------------------------------
# Construct a new property from module, class and business object
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, module, object, pDefs = None):
-
- BaseObject.__init__ (self, sessionManager, 'gnue_property', object, pDefs)
+ def __init__ (self, session, module, object, pDefs = None):
+ BaseObject.__init__ (self, session, 'gnue_property', object, pDefs)
self.__module = module
Modified: trunk/gnue-appserver/src/classrep/__init__.py
===================================================================
--- trunk/gnue-appserver/src/classrep/__init__.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/classrep/__init__.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -38,9 +38,10 @@
# First, load the hardwired default repository
try:
- basedir = os.path.dirname(sys.modules["gnue.appserver.classrep"].__file__)
+ basedir = os.path.dirname
(sys.modules["gnue.appserver.classrep"].__file__)
except:
- basedir = os.path.dirname(__file__)
+ basedir = os.path.dirname (__file__)
+
if not os.path.isfile (os.path.join (basedir, "repository.ini")):
basedir = os.path.join (paths.data, "share", "gnue", "appserver")
@@ -52,8 +53,8 @@
bootcat = RepositoryDefinition (defaultRepository)
# Boot the class repository using this boot-catalogue
- server.modules = ModuleDict (server, session, bootcat)
- server.classes = ClassDict (server, session, server.modules, None, bootcat)
+ server.modules = ModuleDict (session, bootcat)
+ server.classes = ClassDict (session, server.modules, None, bootcat)
server.modules.classdict = server.classes
# and finally refresh the repository from the datasource
Modified: trunk/gnue-appserver/src/classrep/test.py
===================================================================
--- trunk/gnue-appserver/src/classrep/test.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/classrep/test.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -37,6 +37,7 @@
print '\nModule "address":'
m = sm.modules ["address"]
+m._session.setcontext ('address')
# m = sm.modules ["gnue"]
print "%s: %s\n" % (m.gnue_name, m.gnue_comment)
Modified: trunk/gnue-appserver/src/geasInstance.py
===================================================================
--- trunk/gnue-appserver/src/geasInstance.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/geasInstance.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -267,14 +267,13 @@
# procedure doesn't kill appserver.
# (needs to be implemented as an option in gnue-common)
- # Create an object representing the current business object
- obj = Object.Object (self._session.sm, self._session.id,
- self._classdef.fullName,
- {"gnue_id": self._getValue ("gnue_id")})
-
# Create a session object which with the actual session id
sess = Session.Session (self._session.sm, self._session.id)
+ # Create an object representing the current business object
+ obj = Object.Object (sess, self._classdef.fullName,
+ self._getValue ("gnue_id"))
+
# fetch the procedure definition
proceduredef = self._classdef.procedures [procedurename]
Added: trunk/gnue-appserver/src/language/Exceptions.py
===================================================================
--- trunk/gnue-appserver/src/language/Exceptions.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/language/Exceptions.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -0,0 +1,61 @@
+# GNU Enterprise Application Server - Language interface Exceptions
+#
+# Copyright 2003-2004 Free Software Foundation
+#
+# This file is part of GNU Enterprise.
+#
+# GNU Enterprise is free software; you can redistribute it
+# and/or modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2, or (at your option) any later version.
+#
+# GNU Enterprise is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with program; see the file COPYING. If not,
+# write to the Free Software Foundation, Inc., 59 Temple Place
+# - Suite 330, Boston, MA 02111-1307, USA.
+#
+# $Id$
+
+
+# ===========================================================================
+# Base class for all language interface exceptions
+# ===========================================================================
+class ELanguageInterface (Exception):
+
+ def __init__ (self, text):
+ self.__text = text
+ Exception.__init__ (self, self.__text)
+
+ def __repr__ (self):
+ return self.__text
+
+
+# ---------------------------------------------------------------------------
+# General qualification error
+# ---------------------------------------------------------------------------
+class EQualificationError (ELanguageInterface):
+
+ def __init__ (self, text):
+ ELanguageInterface.__init__ (self, text)
+
+# ---------------------------------------------------------------------------
+# Qualification error: no context given
+# ---------------------------------------------------------------------------
+class ENoContext (EQualificationError):
+
+ def __init__ (self, name):
+ msg = "Cannot qualifiy name '%s', no context specified." % name
+ EQualificationError.__init__ (self, msg)
+
+# ---------------------------------------------------------------------------
+# EMemberNotFound: Business object has no such member
+# ---------------------------------------------------------------------------
+class EMemberNotFound (ELanguageInterface):
+ def __init__ (self, aClass, aMember):
+ ELanguageInterface.__init__ (self, "Class '%s' has no member '%s'" %
+ (aClass, aMember))
Property changes on: trunk/gnue-appserver/src/language/Exceptions.py
___________________________________________________________________
Name: svn:keywords
+ Id
Modified: trunk/gnue-appserver/src/language/Object.py
===================================================================
--- trunk/gnue-appserver/src/language/Object.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/language/Object.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -25,7 +25,9 @@
import types
import mx.DateTime
import mx.DateTime.ISO
+
from Procedure import Procedure
+from Exceptions import EMemberNotFound
# ===========================================================================
# Helper methods
@@ -37,135 +39,129 @@
class Object:
# -------------------------------------------------------------------------
- # create a new instance: collection is the owning ObjectList and objData
- # is a dictionary as returned by fetch()
+ # Constructor
# -------------------------------------------------------------------------
- def __init__ (self, server, sessionId, classname, objData=None):
+ def __init__ (self, session, classname, objectId = None):
# we won't trigger __setattr__ here ...
- self.__dict__['_server'] = server
- self.__dict__['_session_id'] = sessionId
- self.__dict__['_class'] = classname
- self.__dict__['_cache'] = {}
- self.__dict__['objectId'] = None
+ self.__dict__['objectId'] = objectId
+ self.__dict__['_Object__session'] = session
+ self.__dict__['_Object__class'] = classname
- # if a dictionary with instance data is given, populate the cache
- if objData:
- self.objectId = objData ['gnue_id']
- if len (objData) > 1:
- # figure out what types the attributes in objData have
- plist = objData.keys ()
- plist.sort ()
- res = self._server.load (self._session_id, self._class, [''], plist)
-
- # NOTE: in Python 2.3 we would use the enumerate () builtin :)
- pix = 0
- for key in plist:
- self._cache [key] = self.rpc_to_native (objData [key], res [0] [pix])
- pix += 1
-
-
# -------------------------------------------------------------------------
# Return an attribute's value; if not available in cache load from server
# -------------------------------------------------------------------------
def __getattr__ (self, attr):
- if not self._cache.has_key (attr):
- if self._attrIsValid (attr):
- if self.objectId:
- res = self._server.load (self._session_id, self._class,
- [self.objectId, ''], [attr])
- # self._cache [attr] = self.rpc_to_native (res [0] [0], res [1] [0])
- return self.rpc_to_native (res [0] [0], res [1] [0])
- else:
- res = self._server.load (self._session_id, self._class, [''], [attr])
- # self._cache [attr] = self.rpc_to_native (None, res [0] [0])
- return self.rpc_to_native (None, res [0] [0])
+ name = self.__session.qualify (attr)
- elif self._attrIsMethod (attr):
- return Procedure (self._server, self._session_id, self.objectId,
- self._class, attr)
+ if self.__attrIsMethod (name):
+ return Procedure (self.__session, self.objectId, self.__class, name)
+
+ elif self.__attrIsValid (name):
+ sm = self.__session.getSessionManager ()
+ sid = self.__session.getSessionId ()
+
+ if self.objectId:
+ res = sm.load (sid, self.__class, [self.objectId, ''], [name])
+ (value, datatype) = (res [0][0], res [1][0])
+
+ # if no objectId is available we assume it's a new object
else:
- raise AttributeError, attr
+ res = sm.load (sid, self.__class, [''], [name])
+ (value, datatype) = (None, res [0][0])
- print "ERR: %s.%s" % (self._class, attr)
- return self._cache [attr]
+ return self.__rpc_to_native (value, datatype)
+ else:
+ raise EMemberNotFound (self.__class, name)
+
# -------------------------------------------------------------------------
# Set an attribute's value
# -------------------------------------------------------------------------
def __setattr__ (self, attr, value):
- if self.__dict__.has_key (attr):
- self.__dict__ [attr] = value
+ if self.__attrIsValid (attr):
+ name = self.__session.qualify (attr)
+ sm = self.__session.getSessionManager ()
+ sid = self.__session.getSessionId ()
+
+ res = sm.store (sid, self.__class, [self.objectId], name,
+ [self.__native_to_rpc (value)])
+ self.objectId = res [0]
+
else:
- if not self._attrIsValid (attr):
- raise AttributeError, attr
+ raise AttributeError, attr
- self._cache [attr] = value
# -------------------------------------------------------------------------
# Return the Object-ID as string representation
# -------------------------------------------------------------------------
- # TODO: check if using __repr__() instead is a better solution
def __str__ (self):
return self.objectId
# -------------------------------------------------------------------------
- # Check if 'attr' is a valid attribute of this class
+ # Check if 'attr' is a valid property of this class
# -------------------------------------------------------------------------
- def _attrIsValid (self, attr):
- return self._server.classes [self._class].properties.has_key (attr)
+ def __attrIsValid (self, attr):
+ name = self.__session.qualify (attr)
+ cdef = self.__session.getSessionManager ().classes [self.__class]
+ return cdef.properties.has_key (name)
# -------------------------------------------------------------------------
# Check if 'attr' is a valid procedure of this class
# -------------------------------------------------------------------------
- def _attrIsMethod (self, attr):
- return self._server.classes [self._class].procedures.has_key (attr)
+ def __attrIsMethod (self, attr):
+ name = self.__session.qualify (attr)
+ cdef = self.__session.getSessionManager ().classes [self.__class]
+ return cdef.procedures.has_key (name)
+
# -------------------------------------------------------------------------
# Get an apropriate default value for type
# -------------------------------------------------------------------------
- def _defaultValue (self, type):
+ def __defaultValue (self, datetype):
# NOTE: we assume None to be default value for all types
return None
+
# -------------------------------------------------------------------------
# Convert RPC transportable type into native python object
# -------------------------------------------------------------------------
- def rpc_to_native (self, value, type):
+ def __rpc_to_native (self, value, datatype):
# Empty strings indicate a default value
if value == '':
- return self._defaultValue (type)
+ return self.__defaultValue (datatype)
# String: convert to unicode
- elif type [:7] == 'string(':
+ elif datatype [:7] == 'string(':
return unicode (value, 'utf-8')
# Date: convert to mx.DateTime object
- elif type == 'date':
+ elif datatype == 'date':
return mx.DateTime.ISO.ParseDate (value)
# Time: convert to mx.DateTime object
- elif type == 'time':
+ elif datatype == 'time':
return mx.DateTime.ISO.ParseTime (value)
# DateTime: convert to mx.DateTime object
- elif type == 'datetime':
+ elif datatype == 'datetime':
return mx.DateTime.ISO.ParseDateTime (value)
# id, number and boolean: no need to convert
- elif type in ['id', 'boolean'] or type [:6] == 'number':
+ elif datatype in ['id', 'boolean'] or datatype [:6] == 'number':
return value
# All others (should be reference-type)
else:
- return Object (self._server, self._session_id, type, {'gnue_id': value})
+ return Object (self.__session, datatype, value)
+
# -------------------------------------------------------------------------
# Convert native Python object into RPC transportable datatype
# -------------------------------------------------------------------------
- def native_to_rpc (self, value):
+ def __native_to_rpc (self, value):
if value is None:
return ''
elif isinstance (value, types.UnicodeType):
@@ -175,27 +171,9 @@
# -------------------------------------------------------------------------
- # Store this instance
- # -------------------------------------------------------------------------
- def store (self):
- data = []
- prop = []
-
- # make sure the property-list and the data-list have the same order
- for key in self._cache.keys ():
- if key == 'gnue_id':
- continue
- prop.append (key)
- data.append (self.native_to_rpc (self._cache [key]))
-
- res = self._server.store (self._session_id, self._class, [self.objectId],
- prop, [data])
- self.objectId = res [0]
-
- # -------------------------------------------------------------------------
# Delete instance and clear object-id
# -------------------------------------------------------------------------
def delete (self):
- self._server.delete (self._session_id, self._class, [self.objectId])
+ self.__session.getSessionManager ().delete (
+ self.__session.getSessionId (), self.__class, [self.objectId])
self.objectId = None
-
Modified: trunk/gnue-appserver/src/language/ObjectList.py
===================================================================
--- trunk/gnue-appserver/src/language/ObjectList.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/language/ObjectList.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -34,24 +34,23 @@
# -------------------------------------------------------------------------
# Constructor
# -------------------------------------------------------------------------
- def __init__ (self, server, sessionId, classname, cond, sort, properties):
- self._server = server
- self._session_id = sessionId
- self._cache = []
+ def __init__ (self, session, classname, cond, sort, properties):
self.classname = classname
self.conditions = cond
self.sortOrder = sort
self.properties = properties
- # prepare the sequence-cache
- self._buildCache ()
+ self.__session = session
+ self.__list = []
+ self.__buildList ()
+
# -------------------------------------------------------------------------
# Return the number of elements in this sequence
# -------------------------------------------------------------------------
def __len__ (self):
- return self._length
+ return self.__length
# -------------------------------------------------------------------------
# Return a slice or a specific element of this sequence
@@ -59,68 +58,88 @@
def __getitem__ (self, index):
try:
if type (index) == types.SliceType:
- return self._cache [index.start:index.stop]
+ return self.__list [index.start:index.stop]
else:
- return self._cache [index]
+ return self.__list [index]
+
except:
- # try to populate the cache for missing entries
- if self._populateCache():
+ # try to populate the sequence with missing entries
+ if self.__populateList ():
# if successful try to return entry/entries again
- return self.__getitem__(index)
+ return self.__getitem__ (index)
else:
raise IndexError
-
-
# -------------------------------------------------------------------------
- # Create a cache for this sequence
+ # Create an initial sequence
# -------------------------------------------------------------------------
- def _buildCache (self):
- self.list_id = self._server.request (self._session_id, self.classname,
- self.conditions, self.sortOrder,
- self.properties)
- # fix for gnue-common 0.5.1 release:
- # - don't depend on RecordSet.Count functionality
- # self._length = self._server.count (self._session_id, self.list_id)
- self._cache = []
+ def __buildList (self):
+ sm = self.__session.getSessionManager ()
+ sid = self.__session.getSessionId ()
- self._populateCache()
+ self.__list_id = sm.request (sid, self.classname, self.conditions,
+ self.sortOrder, self.properties)
+ self.__list = []
+ self.__populateList ()
# -------------------------------------------------------------------------
# Populate Cache
# -------------------------------------------------------------------------
- def _populateCache (self):
- rset = self._server.fetch (self._session_id, self.list_id,
- len (self._cache), CACHE_STEP, 0)
+ def __populateList (self):
+ sm = self.__session.getSessionManager ()
+ sid = self.__session.getSessionId ()
+
+ rset = sm.fetch (sid, self.__list_id, len (self.__list), CACHE_STEP, 0)
for row in rset:
- # Just keep the 'gnue_id' property cached
- objData = {"gnue_id": row [0]}
- # i = 0
- # objData = {}
+ obj = Object (self.__session, self.classname, row [0])
+ self.__list.append (obj)
- # for p in self.properties:
- # objData [p] = row [i+1]
- # i += 1
-
- # objData ["gnue_id"] = row [0]
- obj = Object (self._server, self._session_id, self.classname, objData)
- self._cache.append (obj)
-
# fix for gnue-common 0.5.1 release (will be removed for later releases
# of gnue-common)
- self._length = len (self._cache)
+ self.__length = len (self.__list)
# return number of updated rows
return len (rset)
# -------------------------------------------------------------------------
- # Extend the cached sequence
+ # Append an item to the sequence
# -------------------------------------------------------------------------
def append (self, value):
- self._cache.append (value)
+ self.__list.append (value)
+
+ # -------------------------------------------------------------------------
+ # Extend the sequence by another list
+ # -------------------------------------------------------------------------
+ def extend (self, alist):
+ self.__list.extend (alist)
+
+
+ # -------------------------------------------------------------------------
+ # Returns the index of the first element with a matching key-value-pair
+ # -------------------------------------------------------------------------
+ def index (self, key, value):
+ idx = 0
+ for item in self.__list:
+ if item.key == value:
+ return idx
+ idx += 1
+
+ raise ValueError, "No %s.%s with a value of '%s' found." %
+ (self.classname, key, value)
+
+
+ # -------------------------------------------------------------------------
+ # Returns the number of elements with a matching key-value-pair
+ # -------------------------------------------------------------------------
+ def count (self, key, value):
+ num = 0
+ for item in self.__list:
+ if item.key == value:
+ num += 1
+ return num
Modified: trunk/gnue-appserver/src/language/Procedure.py
===================================================================
--- trunk/gnue-appserver/src/language/Procedure.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/language/Procedure.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: $
+# $Id$
# =============================================================================
# Implement a callable environment for the language interface
@@ -29,17 +29,18 @@
# ---------------------------------------------------------------------------
# Constructor
# ---------------------------------------------------------------------------
- def __init__ (self, sessionManager, sessionId, objectId, className,
- procedureName):
- self._sm = sessionManager
- self._session_id = sessionId
- self._object_id = objectId
- self._class = className
- self.method = procedureName
+ def __init__ (self, session, objectId, className, procedureName):
+ self.method = session.qualify (procedureName)
+ self.__session = session
+ self.__object_id = objectId
+ self.__class = className
+
# ---------------------------------------------------------------------------
# Delegate calls of this object to the session manager
# ---------------------------------------------------------------------------
def __call__ (self, *args, **kwargs):
- self._sm.call (self._session_id, self._class, [self._object_id],
- self.method, args)
+ sm = self.__session.getSessionManager ()
+ sid = self.__session.getSessionId ()
+
+ s.call (sid, self.__class, [self.__objectId], self.method, args)
Modified: trunk/gnue-appserver/src/language/Session.py
===================================================================
--- trunk/gnue-appserver/src/language/Session.py 2004-02-02 22:07:47 UTC
(rev 5064)
+++ trunk/gnue-appserver/src/language/Session.py 2004-02-04 16:04:22 UTC
(rev 5065)
@@ -23,6 +23,7 @@
from ObjectList import ObjectList
from Object import Object
+from Exceptions import ENoContext
# ===========================================================================
@@ -34,50 +35,74 @@
# Constructor
# -------------------------------------------------------------------------
def __init__ (self, sessionManager, sessionId):
- self._sm = sessionManager
- self._session_id = sessionId
+ self.__sm = sessionManager
+ self.__session_id = sessionId
+ self.__context = None
# -------------------------------------------------------------------------
+ # Get the session's sessionManager
+ # -------------------------------------------------------------------------
+ def getSessionManager (self):
+ return self.__sm
+
+ # -------------------------------------------------------------------------
+ # Get the session's id
+ # -------------------------------------------------------------------------
+ def getSessionId (self):
+ return self.__session_id
+
+ # -------------------------------------------------------------------------
+ # Set the default context
+ # -------------------------------------------------------------------------
+ def setcontext (self, context):
+ self.__context = context
+
+ # -------------------------------------------------------------------------
+ # Ensure the given name is fully qualified using the current context
+ # -------------------------------------------------------------------------
+ def qualify (self, name):
+ if '_' in name:
+ return name
+ else:
+ if self.__context is None:
+ raise ENoContext (name)
+ else:
+ return "%s_%s" % (self.__context, name)
+
+
+ # -------------------------------------------------------------------------
# Close the session
# -------------------------------------------------------------------------
def close (self):
- if self._sm:
- self._sm.close (self._session_id, None)
- self._sm = self._session_id = None
+ if self.__sm is not None:
+ self.__sm.close (self.__session_id, None)
+ self.__sm = self.__session_id = None
# -------------------------------------------------------------------------
# Commit the current transaction
# -------------------------------------------------------------------------
def commit (self):
- if self._session_id:
- self._sm.commit (self._session_id)
+ if self.__session_id is not None:
+ self.__sm.commit (self.__session_id)
# -------------------------------------------------------------------------
# Revoke the current transaction
# -------------------------------------------------------------------------
def rollback (self):
- if self._session_id:
- self._sm.rollback (self._session_id)
+ if self.__session_id is not None:
+ self.__sm.rollback (self.__session_id)
# -------------------------------------------------------------------------
- # Set the default context
- # -------------------------------------------------------------------------
- def setcontext (self, context):
- if self._session_id:
- self._sm.setcontext (self._session_id, context)
-
- # -------------------------------------------------------------------------
# Return a collection of 'classname' matching the given arguments
# -------------------------------------------------------------------------
def find (self, classname, cond=[], sort=['gnue_id'], properties=[]):
- return ObjectList (self._sm, self._session_id, classname, cond, sort,
- properties)
+ return ObjectList (self, classname, cond, sort, properties)
# -------------------------------------------------------------------------
# Create a new instance of classname
# -------------------------------------------------------------------------
def new (self, classname):
- return Object (self._sm, self._session_id, classname)
+ return Object (self, classname)
@@ -90,11 +115,10 @@
# Constructor
# -------------------------------------------------------------------------
def __init__ (self, sessionManager, user, password):
- sessionId = sessionManager.open ({'user': user, 'password': password})
- Session.__init__ (self, sessionManager, sessionId)
+ Session.__init__ (self, sessionManager,
+ sessionManager.open ({'user': user, 'password': password}))
-
# =============================================================================
# InternalSession uses 0 as Session-Id
# =============================================================================
Modified: trunk/gnue-appserver/src/language/test.py
===================================================================
--- trunk/gnue-appserver/src/language/test.py 2004-02-02 22:07:47 UTC (rev
5064)
+++ trunk/gnue-appserver/src/language/test.py 2004-02-04 16:04:22 UTC (rev
5065)
@@ -25,8 +25,11 @@
from gnue.appserver.language import App
app = App.App ()
+
+print "requesting new session ..."
session = app.newSession ('test', 'test')
+print "fetching all persons..."
list = session.find ('address_person', sort = ['address_name'],
properties = ['address_name', 'address_street'])
Modified: trunk/gnue-appserver/src/test.py
===================================================================
--- trunk/gnue-appserver/src/test.py 2004-02-02 22:07:47 UTC (rev 5064)
+++ trunk/gnue-appserver/src/test.py 2004-02-04 16:04:22 UTC (rev 5065)
@@ -19,7 +19,7 @@
# write to the Free Software Foundation, Inc., 59 Temple Place
# - Suite 330, Boston, MA 02111-1307, USA.
#
-# $Id: test.py,v 1.19 2003/10/09 21:42:10 siesel Exp $
+# $Id$
import os
from gnue.common.apps import GClientApp
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- r5065 - in trunk/gnue-appserver/src: . classrep language,
johannes <=