Merge pull request #90 from intermine/bitfount

Bitfount

Author: Daniela Butano

intermine/lists/listmanager.py

@@ -256,6 +256,7 @@ def create_list(
                     This only makes sense with text uploads
                     - it is not required (or used) when
                     the content is a list or a query.
+        @param organism: organism name
 
         @rtype: intermine.lists.List
         """

intermine/query.py

@@ -1835,8 +1835,31 @@ def __init__(self, *args, **kwargs):
         super(Template, self).__init__(*args, **kwargs)
         self.constraint_factory = constraints.TemplateConstraintFactory()
         self.title = ''
+        self.user_name = ''
         self.view_types = []
 
+    def clone(self):
+        """
+        Performs a deep clone
+        =====================
+
+        This method will produce a clone that is independent,
+        and can be altered without affecting the original,
+        but starts off with the exact same state as it.
+
+        The only shared elements should be the model
+        and the service, which are shared by all queries
+        that refer to the same webservice.
+
+        @return: same class as caller
+        """
+        newobj = super(Template, self).clone()
+        setattr(newobj, "user_name", getattr(self, "user_name"))
+        return newobj
+
+    def add_user_name(self, user_name):
+        self.user_name = user_name
+
     @classmethod
     def from_xml(cls, xml, *args, **kwargs):
         """
@@ -1914,7 +1937,7 @@ def to_query_params(self):
 
         @rtype: dict
         """
-        p = {'name': self.name}
+        p = {'name': self.name, 'userName': self.user_name}
         i = 1
         for c in self.editable_constraints:
             if not c.switched_on:
@@ -1964,6 +1987,7 @@ def get_adjusted_template(self, con_values):
         @rtype: L{Template}
         """
         clone = self.clone()
+
         for code, options in list(con_values.items()):
             con = clone.get_constraint(code)
             if not con.editable:
@@ -2031,7 +2055,6 @@ def get_row_list(self, start=0, size=None, **con_values):
         return super(Template, clone).get_row_list(start, size)
 
     def rows(self, start=0, size=None, **con_values):
-        print("basil2")
         """Get an iterator over the rows returned by this query"""
         clone = self.get_adjusted_template(con_values)
         return super(Template, clone).rows(start, size)

intermine/webservice.py

@@ -211,6 +211,7 @@ class Service(object):
     MODEL_PATH = '/model'
     TEMPLATES_PATH = '/templates'
     TEMPLATEQUERY_PATH = '/template/results'
+    ALL_TEMPLATES_PATH = '/alltemplates'
     LIST_PATH = '/lists'
     LIST_CREATION_PATH = '/lists'
     LIST_RENAME_PATH = '/lists/rename'
@@ -270,6 +271,8 @@ def __init__(self, root,
         self.prefetch_id_only = prefetch_id_only
         # Initialize empty cached data.
         self._templates = None
+        self._all_templates = None
+        self._all_templates_names = None
         self._model = None
         self._version = None
         self._release = None
@@ -488,6 +491,44 @@ def get_template(self, name):
             self.templates[name] = t
         return t
 
+    def get_template_by_user(self, name, username):
+        """
+        Returns a template of the given name belonging to username
+        ==========================================================
+
+        Tries to retrieve a template of the given name belonging
+        to the username from the webservice. You need to authenticate
+        as admin
+
+        @see: L{intermine.webservice.Service.__init__}
+
+        @param name: the template's name
+        @type name: string
+
+        @param username: the username
+        @type name: string
+
+        @raise ServiceError: if the template or user does not exist
+        @raise QueryParseError: if the template cannot be parsed
+
+        @return: L{intermine.query.Template}
+        """
+        try:
+            templates = self.all_templates[username]
+        except KeyError:
+            raise ServiceError("There is no user called '" + username + "'")
+        try:
+            t = templates[name]
+        except KeyError:
+            raise ServiceError("There is no template called '"
+                               + name + "' at this service belonging to '"
+                               + username + "'")
+        if not isinstance(t, Template):
+            t = Template.from_xml(t, self.model, self)
+            t.user_name = username
+            self.all_templates[name] = t
+        return t
+
     def _get_json(self, path, payload=None):
         headers = {'Accept': 'application/json'}
         with closing(self.opener.open(self.root + path, payload,
@@ -605,6 +646,8 @@ def flush(self):
         self._list_manager.delete_temporary_lists()
         self._list_manager = ListManager(self)
         self._templates = None
+        self._all_templates = None
+        self._all_templates_names = None
         self._model = None
         self._version = None
         self._release = None
@@ -644,6 +687,80 @@ def templates(self):
             self._templates = templates
         return self._templates
 
+    @property
+    def all_templates(self):
+        """
+        The dictionary of templates by users from the webservice
+        ========================================================
+
+        Service.all_templates S{->} dict(string|string)
+
+        You need to be authenticated as admin.
+
+        For efficiency's sake, Templates are not parsed until
+        they are required, and until then they are stored as XML
+        strings. It is recommended that in most cases you would want
+        to use L{Service.get_template}.
+
+        You can use this property however to test for template existence::
+
+         if name in service.templates:
+           template = service.get_template(name)
+
+        @rtype: dict
+
+        """
+        if self._all_templates is None:
+            all_templates = {}
+            dom = self._get_xml(self.ALL_TEMPLATES_PATH)
+            for e in dom.getElementsByTagName('template'):
+                user = e.getAttribute('userName')
+                name = e.getAttribute('name')
+                if user in all_templates:
+                    templates = all_templates[user]
+                    templates[name] = e.toxml()
+                else:
+                    templates = {}
+                    templates[name] = e.toxml()
+                    all_templates[user] = templates
+            self._all_templates = all_templates
+        return self._all_templates
+
+    @property
+    def all_templates_names(self):
+        """
+        The dictionary of templates names by users from the webservice
+        =============================================================
+
+        Service.all_templates_names S{->} dict(string|array)
+
+        You need to be authenticated as admin.
+
+        Example::
+          allTemplatesNames = service.all_templates_names
+          for user in allTemplatesNames:
+            userTemplatesNames = allTemplatesNames[user]
+            for templateName in userTemplatesNames:
+              template = service.get_template_by_user(templateName, user)
+
+        @rtype: dict
+
+        """
+        if self._all_templates_names is None:
+            all_templates_names = {}
+            dom = self._get_xml(self.ALL_TEMPLATES_PATH)
+            for e in dom.getElementsByTagName('template'):
+                user = e.getAttribute('userName')
+                name = e.getAttribute('name')
+                if user in all_templates_names:
+                    all_templates_names[user].append(name)
+                else:
+                    templates_names = []
+                    templates_names.append(name)
+                    all_templates_names[user] = templates_names
+            self._all_templates_names = all_templates_names
+        return self._all_templates_names
+
     @property
     def model(self):
         """

tests/test_core.py

@@ -1025,6 +1025,7 @@ def testURLs(self):
 
         expected1 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',
@@ -1041,6 +1042,7 @@ def testURLs(self):
 
         expected1 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',
@@ -1057,6 +1059,7 @@ def testURLs(self):
 
         expected2 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',
@@ -1076,6 +1079,7 @@ def testURLs(self):
 
         expected2 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',
@@ -1108,6 +1112,7 @@ def testURLs(self):
         # Check that we can just use strings for simple value replacement.
         expected3 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',
@@ -1128,6 +1133,7 @@ def testURLs(self):
         self.assertEqual(expected1, t.rows())
         expected1 = ('/TEMPLATE-PATH', {
             'name': 'TEST-TEMPLATE',
+            'userName': '',
             'code1': 'A',
             'code2': 'B',
             'constraint1': 'Employee.name',