Be consistent in the API.

diff --git a/PLC/AddressTypes.py b/PLC/AddressTypes.py
index 74bf0f7..15b0ea1 100644 (file)
--- a/PLC/AddressTypes.py
+++ b/PLC/AddressTypes.py
@@ -63,5 +63,13 @@ class AddressTypes(Table):
             elif isinstance(address_type_filter, dict):
                 address_type_filter = Filter(AddressType.fields, address_type_filter)
                 sql += " AND (%s) %s" % address_type_filter.sql(api, "AND")
+            elif isinstance(address_type_filter, (int, long)):
+                address_type_filter = Filter(AddressType.fields, {'address_type_id': address_type_filter})
+                sql += " AND (%s) %s" % address_type_filter.sql(api, "AND")
+            elif isinstance(address_type_filter, StringTypes):
+                address_type_filter = Filter(AddressType.fields, {'name': address_type_filter})
+                sql += " AND (%s) %s" % address_type_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong address type filter %r"%address_type_filter
 
         self.selectall(sql)

diff --git a/PLC/Addresses.py b/PLC/Addresses.py
index 8098ce0..c4772b4 100644 (file)
--- a/PLC/Addresses.py
+++ b/PLC/Addresses.py
@@ -93,7 +93,7 @@ class Addresses(Table):
               ", ".join(self.columns)
 
         if address_filter is not None:
-            if isinstance(address_filter, (list, tuple, set)):
+            if isinstance(address_filter, (list, tuple, set, int, long)):
                 address_filter = Filter(Address.fields, {'address_id': address_filter})
             elif isinstance(address_filter, dict):
                 address_filter = Filter(Address.fields, address_filter)

diff --git a/PLC/ConfFiles.py b/PLC/ConfFiles.py
index 1db8b4a..0efeb9e 100644 (file)
--- a/PLC/ConfFiles.py
+++ b/PLC/ConfFiles.py
@@ -147,7 +147,7 @@ class ConfFiles(Table):
               ", ".join(self.columns)
 
         if conf_file_filter is not None:
-            if isinstance(conf_file_filter, (list, tuple, set)):
+            if isinstance(conf_file_filter, (list, tuple, set, int, long)):
                 conf_file_filter = Filter(ConfFile.fields, {'conf_file_id': conf_file_filter})
             elif isinstance(conf_file_filter, dict):
                 conf_file_filter = Filter(ConfFile.fields, conf_file_filter)

diff --git a/PLC/EventObjects.py b/PLC/EventObjects.py
index 15b89f8..c2d53ee 100644 (file)
--- a/PLC/EventObjects.py
+++ b/PLC/EventObjects.py
@@ -47,15 +47,12 @@ class EventObjects(Table):
             ", ".join(self.columns)
 
         if event_filter is not None:
-            if isinstance(event_filter, (list, tuple, set)):
+            if isinstance(event_filter, (list, tuple, set, int, long)):
                 event_filter = Filter(EventObject.fields, {'event_id': event_filter})
                 sql += " AND (%s) %s" % event_filter.sql(api, "OR")
             elif isinstance(event_filter, dict):
                 event_filter = Filter(EventObject.fields, event_filter)
                 sql += " AND (%s) %s" % event_filter.sql(api, "AND")
-            elif isinstance (event_filter, int):
-                event_filter = Filter(EventObject.fields, {'event_id':[event_filter]})
-                sql += " AND (%s) %s" % event_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong event object filter %r"%event_filter
 

diff --git a/PLC/Events.py b/PLC/Events.py
index b8ad6e8..e0f0d31 100644 (file)
--- a/PLC/Events.py
+++ b/PLC/Events.py
@@ -70,9 +70,11 @@ class Events(Table):
               ", ".join(self.columns)
 
         if event_filter is not None:
-            if isinstance(event_filter, (list, tuple, set)):
+            if isinstance(event_filter, (list, tuple, set, int, long)):
                 event_filter = Filter(Event.fields, {'event_id': event_filter})
             elif isinstance(event_filter, dict):
                 event_filter = Filter(Event.fields, event_filter)
+            else:
+                raise PLCInvalidArgument, "Wrong event object filter %r"%event_filter
             sql += " AND (%s) %s" % event_filter.sql(api)
         self.selectall(sql)

diff --git a/PLC/Ilinks.py b/PLC/Ilinks.py
index 5015236..8cd97ae 100644 (file)
--- a/PLC/Ilinks.py
+++ b/PLC/Ilinks.py
@@ -39,12 +39,10 @@ class Ilinks(Table):
               ", ".join(self.columns)
 
         if ilink_filter is not None:
-            if isinstance(ilink_filter, (list, tuple, set)):
+            if isinstance(ilink_filter, (list, tuple, set, int, long)):
                 ilink_filter = Filter(Ilink.fields, {'ilink_id': ilink_filter})
             elif isinstance(ilink_filter, dict):
                 ilink_filter = Filter(Ilink.fields, ilink_filter)
-            elif isinstance(ilink_filter, int):
-                ilink_filter = Filter(Ilink.fields, {'ilink_id': [ilink_filter]})
             else:
                 raise PLCInvalidArgument, "Wrong ilink filter %r"%ilink_filter
             sql += " AND (%s) %s" % ilink_filter.sql(api)

diff --git a/PLC/InitScripts.py b/PLC/InitScripts.py
index 3323dcd..32c11d8 100644 (file)
--- a/PLC/InitScripts.py
+++ b/PLC/InitScripts.py
@@ -64,5 +64,13 @@ class InitScripts(Table):
             elif isinstance(initscript_filter, dict):
                 initscript_filter = Filter(InitScript.fields, initscript_filter)
                 sql += " AND (%s) %s" % initscript_filter.sql(api, "AND")
+            elif isinstance(initscript_filter, (int, long)):
+                initscript_filter = Filter(InitScript.fields, {'initscript_id': initscript_filter})
+                sql += " AND (%s) %s" % initscript_filter.sql(api, "AND")
+            elif isinstance(initscript_filter, StringTypes):
+                initscript_filter = Filter(InitScript.fields, {'name': initscript_filter})
+                sql += " AND (%s) %s" % initscript_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong initscript filter %r"%initscript_filter
 
         self.selectall(sql)

diff --git a/PLC/InterfaceTags.py b/PLC/InterfaceTags.py
index 87e2226..976a54e 100644 (file)
--- a/PLC/InterfaceTags.py
+++ b/PLC/InterfaceTags.py
@@ -47,12 +47,10 @@ class InterfaceTags(Table):
               ", ".join(self.columns)
 
         if interface_tag_filter is not None:
-            if isinstance(interface_tag_filter, (list, tuple, set)):
+            if isinstance(interface_tag_filter, (list, tuple, set, int, long)):
                 interface_tag_filter = Filter(InterfaceTag.fields, {'interface_tag_id': interface_tag_filter})
             elif isinstance(interface_tag_filter, dict):
                 interface_tag_filter = Filter(InterfaceTag.fields, interface_tag_filter)
-            elif isinstance(interface_tag_filter, int):
-                interface_tag_filter = Filter(InterfaceTag.fields, {'interface_tag_id': [interface_tag_filter]})
             else:
                 raise PLCInvalidArgument, "Wrong interface setting filter %r"%interface_tag_filter
             sql += " AND (%s) %s" % interface_tag_filter.sql(api)

diff --git a/PLC/Keys.py b/PLC/Keys.py
index 5318966..0c0b5a8 100644 (file)
--- a/PLC/Keys.py
+++ b/PLC/Keys.py
@@ -110,10 +110,12 @@ class Keys(Table):
               ", ".join(self.columns)
 
         if key_filter is not None:
-            if isinstance(key_filter, (list, tuple, set)):
+            if isinstance(key_filter, (list, tuple, set, int, long)):
                 key_filter = Filter(Key.fields, {'key_id': key_filter})
             elif isinstance(key_filter, dict):
                 key_filter = Filter(Key.fields, key_filter)
+            else:
+                raise PLCInvalidArgument, "Wrong key filter %r"%key_filter
             sql += " AND (%s) %s" % key_filter.sql(api)
 
         self.selectall(sql)

diff --git a/PLC/Leases.py b/PLC/Leases.py
index 4b967c6..7211516 100644 (file)
--- a/PLC/Leases.py
+++ b/PLC/Leases.py
@@ -80,10 +80,7 @@ class Leases(Table):
 
 
         if lease_filter is not None:
-
-            if isinstance (lease_filter, int):
-                lease_filter = Filter (Lease.fields, {'lease_id': lease_filter})
-            elif isinstance(lease_filter, (list, tuple, set)):
+            if isinstance(lease_filter, (list, tuple, set, int, long)):
                 lease_filter = Filter(Lease.fields, {'lease_id': lease_filter})
             elif isinstance(lease_filter, dict):
                 lease_filter = LeaseFilter(Lease.fields, lease_filter)

diff --git a/PLC/Messages.py b/PLC/Messages.py
index dfc1c9f..898047e 100644 (file)
--- a/PLC/Messages.py
+++ b/PLC/Messages.py
@@ -41,11 +41,13 @@ class Messages(Table):
             sql += " AND enabled IS %s" % enabled
 
         if message_filter is not None:
-            if isinstance(message_filter, (list, tuple, set)):
+            if isinstance(message_filter, (list, tuple, set, int, long)):
                 message_filter = Filter(Message.fields, {'message_id': message_filter})
                 sql += " AND (%s) %s" % message_filter.sql(api, "OR")
             elif isinstance(message_filter, dict):
                 message_filter = Filter(Message.fields, message_filter)
                 sql += " AND (%s) %s" % message_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong message filter %r"%message_filter
 
         self.selectall(sql)

diff --git a/PLC/Methods/DeleteAddress.py b/PLC/Methods/DeleteAddress.py
index bc6ba5e..c49175d 100644 (file)
--- a/PLC/Methods/DeleteAddress.py
+++ b/PLC/Methods/DeleteAddress.py
@@ -27,7 +27,7 @@ class DeleteAddress(Method):
 
     def call(self, auth, address_id):
         # Get associated address details
-        addresses = Addresses(self.api, [address_id])
+        addresses = Addresses(self.api, address_id)
         if not addresses:
             raise PLCInvalidArgument, "No such address"
         address = addresses[0]

diff --git a/PLC/NodeGroups.py b/PLC/NodeGroups.py
index 3705644..665525c 100644 (file)
--- a/PLC/NodeGroups.py
+++ b/PLC/NodeGroups.py
@@ -101,5 +101,13 @@ class NodeGroups(Table):
             elif isinstance(nodegroup_filter, dict):
                 nodegroup_filter = Filter(NodeGroup.fields, nodegroup_filter)
                 sql += " AND (%s) %s" % nodegroup_filter.sql(api, "AND")
+            elif isinstance(nodegroup_filter, (int, long)):
+                nodegroup_filter = Filter(NodeGroup.fields, {'nodegroup_id': nodegroup_filter})
+                sql += " AND (%s) %s" % nodegroup_filter.sql(api, "AND")
+            elif isinstance(nodegroup_filter, StringTypes):
+                nodegroup_filter = Filter(NodeGroup.fields, {'groupname': nodegroup_filter})
+                sql += " AND (%s) %s" % nodegroup_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong node group filter %r"%nodegroup_filter
 
         self.selectall(sql)

diff --git a/PLC/NodeTags.py b/PLC/NodeTags.py
index b177e49..9e29192 100644 (file)
--- a/PLC/NodeTags.py
+++ b/PLC/NodeTags.py
@@ -43,12 +43,10 @@ class NodeTags(Table):
               ", ".join(self.columns)
 
         if node_tag_filter is not None:
-            if isinstance(node_tag_filter, (list, tuple, set)):
+            if isinstance(node_tag_filter, (list, tuple, set, int, long)):
                 node_tag_filter = Filter(NodeTag.fields, {'node_tag_id': node_tag_filter})
             elif isinstance(node_tag_filter, dict):
                 node_tag_filter = Filter(NodeTag.fields, node_tag_filter)
-            elif isinstance(node_tag_filter, int):
-                node_tag_filter = Filter(NodeTag.fields, {'node_tag_id': [node_tag_filter]})
             else:
                 raise PLCInvalidArgument, "Wrong node tag filter %r"%node_tag_filter
             sql += " AND (%s) %s" % node_tag_filter.sql(api)

diff --git a/PLC/Nodes.py b/PLC/Nodes.py
index 96cce36..66c9039 100644 (file)
--- a/PLC/Nodes.py
+++ b/PLC/Nodes.py
@@ -325,10 +325,10 @@ class Nodes(Table):
                 node_filter = Filter(allowed_fields, node_filter)
                 sql += " AND (%s) %s" % node_filter.sql(api, "AND")
             elif isinstance (node_filter, StringTypes):
-                node_filter = Filter(Node.fields, {'hostname':[node_filter]})
+                node_filter = Filter(Node.fields, {'hostname':node_filter})
                 sql += " AND (%s) %s" % node_filter.sql(api, "AND")
-            elif isinstance (node_filter, int):
-                node_filter = Filter(Node.fields, {'node_id':[node_filter]})
+            elif isinstance (node_filter, (int, long)):
+                node_filter = Filter(Node.fields, {'node_id':node_filter})
                 sql += " AND (%s) %s" % node_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong node filter %r"%node_filter

diff --git a/PLC/PCUProtocolTypes.py b/PLC/PCUProtocolTypes.py
index dc3cb03..ca4527c 100644 (file)
--- a/PLC/PCUProtocolTypes.py
+++ b/PLC/PCUProtocolTypes.py
@@ -57,17 +57,11 @@ class PCUProtocolTypes(Table):
               ", ".join(self.columns)
 
         if protocol_type_filter is not None:
-            if isinstance(protocol_type_filter, (list, tuple, set)):
-                # Separate the list into integers and strings
-                ints = filter(lambda x: isinstance(x, (int, long)), protocol_type_filter)
-                protocol_type_filter = Filter(PCUProtocolType.fields, {'pcu_protocol_type_id': ints})
+            if isinstance(protocol_type_filter, (list, tuple, set, int, long)):
+                protocol_type_filter = Filter(PCUProtocolType.fields, {'pcu_protocol_type_id': protocol_type_filter})
                 sql += " AND (%s) %s" % protocol_type_filter.sql(api, "OR")
             elif isinstance(protocol_type_filter, dict):
                 protocol_type_filter = Filter(PCUProtocolType.fields, protocol_type_filter)
-                sql += " AND (%s) %s" % protocol_type_filter.sql(api, "AND")
-            elif isinstance (protocol_type_filter, int):
-                protocol_type_filter = Filter(PCUProtocolType.fields, {'pcu_protocol_type_id':[protocol_type_filter]})
-
                 sql += " AND (%s) %s" % protocol_type_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong pcu_protocol_type filter %r"%protocol_type_filter

diff --git a/PLC/PCUTypes.py b/PLC/PCUTypes.py
index 0839f5b..2dfda73 100644 (file)
--- a/PLC/PCUTypes.py
+++ b/PLC/PCUTypes.py
@@ -77,10 +77,10 @@ class PCUTypes(Table):
                 pcu_type_filter = Filter(PCUType.fields, pcu_type_filter)
                 sql += " AND (%s) %s" % pcu_type_filter.sql(api, "AND")
             elif isinstance (pcu_type_filter, StringTypes):
-                pcu_type_filter = Filter(PCUType.fields, {'model':[pcu_type_filter]})
+                pcu_type_filter = Filter(PCUType.fields, {'model':pcu_type_filter})
                 sql += " AND (%s) %s" % pcu_type_filter.sql(api, "AND")
             elif isinstance (pcu_type_filter, int):
-                pcu_type_filter = Filter(PCUType.fields, {'pcu_type_id':[pcu_type_filter]})
+                pcu_type_filter = Filter(PCUType.fields, {'pcu_type_id':pcu_type_filter})
                 sql += " AND (%s) %s" % pcu_type_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong pcu_type filter %r"%pcu_type_filter

diff --git a/PLC/PCUs.py b/PLC/PCUs.py
index 98d5be3..693f875 100644 (file)
--- a/PLC/PCUs.py
+++ b/PLC/PCUs.py
@@ -126,10 +126,12 @@ class PCUs(Table):
               ", ".join(self.columns)
 
         if pcu_filter is not None:
-            if isinstance(pcu_filter, (list, tuple, set)):
+            if isinstance(pcu_filter, (list, tuple, set, int, long)):
                 pcu_filter = Filter(PCU.fields, {'pcu_id': pcu_filter})
             elif isinstance(pcu_filter, dict):
                 pcu_filter = Filter(PCU.fields, pcu_filter)
+            else:
+                raise PLCInvalidArgument, "Wrong pcu filter %r"%pcu_filter
             sql += " AND (%s) %s" % pcu_filter.sql(api)
 
         self.selectall(sql)

diff --git a/PLC/Peers.py b/PLC/Peers.py
index 1acba4a..fb47b6e 100644 (file)
--- a/PLC/Peers.py
+++ b/PLC/Peers.py
@@ -294,5 +294,13 @@ class Peers (Table):
             elif isinstance(peer_filter, dict):
                 peer_filter = Filter(Peer.fields, peer_filter)
                 sql += " AND (%s) %s" % peer_filter.sql(api, "AND")
+            elif isinstance(peer_filter, (int, long)):
+                peer_filter = Filter(Peer.fields, {'peer_id': peer_filter})
+                sql += " AND (%s) %s" % peer_filter.sql(api, "AND")
+            elif isinstance(peer_filter, StringTypes):
+                peer_filter = Filter(Peer.fields, {'peername': peer_filter})
+                sql += " AND (%s) %s" % peer_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong peer filter %r"%peer_filter
 
         self.selectall(sql)

diff --git a/PLC/PersonTags.py b/PLC/PersonTags.py
index fb9acc0..be1e86e 100644 (file)
--- a/PLC/PersonTags.py
+++ b/PLC/PersonTags.py
@@ -45,12 +45,10 @@ class PersonTags(Table):
               ", ".join(self.columns)
 
         if person_tag_filter is not None:
-            if isinstance(person_tag_filter, (list, tuple, set)):
+            if isinstance(person_tag_filter, (list, tuple, set, int, long)):
                 person_tag_filter = Filter(PersonTag.fields, {'person_tag_id': person_tag_filter})
             elif isinstance(person_tag_filter, dict):
                 person_tag_filter = Filter(PersonTag.fields, person_tag_filter)
-            elif isinstance(person_tag_filter, int):
-                person_tag_filter = Filter(PersonTag.fields, {'person_tag_id': [person_tag_filter]})
             else:
                 raise PLCInvalidArgument, "Wrong person setting filter %r"%person_tag_filter
             sql += " AND (%s) %s" % person_tag_filter.sql(api)

diff --git a/PLC/Persons.py b/PLC/Persons.py
index 7917306..e0e4c84 100644 (file)
--- a/PLC/Persons.py
+++ b/PLC/Persons.py
@@ -393,10 +393,10 @@ class Persons(Table):
                 person_filter = Filter(Person.fields, person_filter)
                 sql += " AND (%s) %s" % person_filter.sql(api, "AND")
             elif isinstance (person_filter, StringTypes):
-                person_filter = Filter(Person.fields, {'email':[person_filter]})
+                person_filter = Filter(Person.fields, {'email':person_filter})
                 sql += " AND (%s) %s" % person_filter.sql(api, "AND")
-            elif isinstance (person_filter, int):
-                person_filter = Filter(Person.fields, {'person_id':[person_filter]})
+            elif isinstance (person_filter, (int, long)):
+                person_filter = Filter(Person.fields, {'person_id':person_filter})
                 sql += " AND (%s) %s" % person_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong person filter %r"%person_filter

diff --git a/PLC/Roles.py b/PLC/Roles.py
index 28fae35..03d9884 100644 (file)
--- a/PLC/Roles.py
+++ b/PLC/Roles.py
@@ -69,5 +69,13 @@ class Roles(Table):
             elif isinstance(role_filter, dict):
                 role_filter = Filter(Role.fields, role_filter)
                 sql += " AND (%s) %s" % role_filter.sql(api, "AND")
+            elif isinstance(role_filter, (int, long)):
+                role_filter = Filter(Role.fields, {'role_id': role_filter})
+                sql += " AND (%s) %s" % role_filter.sql(api, "AND")
+            elif isinstance(role_filter, StringTypes):
+                role_filter = Filter(Role.fields, {'name': role_filter})
+                sql += " AND (%s) %s" % role_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong role filter %r"%role_filter
 
         self.selectall(sql)

diff --git a/PLC/Sessions.py b/PLC/Sessions.py
index 3e4355d..af05d95 100644 (file)
--- a/PLC/Sessions.py
+++ b/PLC/Sessions.py
@@ -82,6 +82,14 @@ class Sessions(Table):
             elif isinstance(session_filter, dict):
                 session_filter = Filter(Session.fields, session_filter)
                 sql += " AND (%s) %s" % session_filter.sql(api, "AND")
+            elif isinstance(session_filter, (int, long)):
+                session_filter = Filter(Session.fields, {'person_id': session_filter})
+                sql += " AND (%s) %s" % session_filter.sql(api, "AND")
+            elif isinstance(session_filter, StringTypes):
+                session_filter = Filter(Session.fields, {'session_id': session_filter})
+                sql += " AND (%s) %s" % session_filter.sql(api, "AND")
+            else:
+                raise PLCInvalidArgument, "Wrong session filter"%session_filter
 
         if expires is not None:
             if expires >= 0:

diff --git a/PLC/SiteTags.py b/PLC/SiteTags.py
index 6ae4ded..c70a46c 100644 (file)
--- a/PLC/SiteTags.py
+++ b/PLC/SiteTags.py
@@ -45,12 +45,10 @@ class SiteTags(Table):
               ", ".join(self.columns)
 
         if site_tag_filter is not None:
-            if isinstance(site_tag_filter, (list, tuple, set)):
+            if isinstance(site_tag_filter, (list, tuple, set, int, long)):
                 site_tag_filter = Filter(SiteTag.fields, {'site_tag_id': site_tag_filter})
             elif isinstance(site_tag_filter, dict):
                 site_tag_filter = Filter(SiteTag.fields, site_tag_filter)
-            elif isinstance(site_tag_filter, int):
-                site_tag_filter = Filter(SiteTag.fields, {'site_tag_id': [site_tag_filter]})
             else:
                 raise PLCInvalidArgument, "Wrong site setting filter %r"%site_tag_filter
             sql += " AND (%s) %s" % site_tag_filter.sql(api)

diff --git a/PLC/Sites.py b/PLC/Sites.py
index dafa8cb..fca3b14 100644 (file)
--- a/PLC/Sites.py
+++ b/PLC/Sites.py
@@ -263,10 +263,10 @@ class Sites(Table):
                 site_filter = Filter(Site.fields, site_filter)
                 sql += " AND (%s) %s" % site_filter.sql(api, "AND")
             elif isinstance (site_filter, StringTypes):
-                site_filter = Filter(Site.fields, {'login_base':[site_filter]})
+                site_filter = Filter(Site.fields, {'login_base':site_filter})
                 sql += " AND (%s) %s" % site_filter.sql(api, "AND")
-            elif isinstance (site_filter, int):
-                site_filter = Filter(Site.fields, {'site_id':[site_filter]})
+            elif isinstance (site_filter, (int, long)):
+                site_filter = Filter(Site.fields, {'site_id':site_filter})
                 sql += " AND (%s) %s" % site_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong site filter %r"%site_filter

diff --git a/PLC/SliceTags.py b/PLC/SliceTags.py
index 11adfd6..a320e62 100644 (file)
--- a/PLC/SliceTags.py
+++ b/PLC/SliceTags.py
@@ -45,10 +45,12 @@ class SliceTags(Table):
               ", ".join(self.columns)
 
         if slice_tag_filter is not None:
-            if isinstance(slice_tag_filter, (list, tuple, set)):
+            if isinstance(slice_tag_filter, (list, tuple, set, int, long)):
                 slice_tag_filter = Filter(SliceTag.fields, {'slice_tag_id': slice_tag_filter})
             elif isinstance(slice_tag_filter, dict):
                 slice_tag_filter = Filter(SliceTag.fields, slice_tag_filter)
+            else:
+                raise PLCInvalidArgument, "Wrong slice tag filter %r"%slice_tag_filter
             sql += " AND (%s) %s" % slice_tag_filter.sql(api)
 
         self.selectall(sql)

diff --git a/PLC/Slices.py b/PLC/Slices.py
index 59a592b..8b4b82a 100644 (file)
--- a/PLC/Slices.py
+++ b/PLC/Slices.py
@@ -286,10 +286,10 @@ class Slices(Table):
                 slice_filter = Filter(Slice.fields, slice_filter)
                 sql += " AND (%s) %s" % slice_filter.sql(api, "AND")
             elif isinstance (slice_filter, StringTypes):
-                slice_filter = Filter(Slice.fields, {'name':[slice_filter]})
+                slice_filter = Filter(Slice.fields, {'name':slice_filter})
                 sql += " AND (%s) %s" % slice_filter.sql(api, "AND")
-            elif isinstance (slice_filter, int):
-                slice_filter = Filter(Slice.fields, {'slice_id':[slice_filter]})
+            elif isinstance (slice_filter, (int, long)):
+                slice_filter = Filter(Slice.fields, {'slice_id':slice_filter})
                 sql += " AND (%s) %s" % slice_filter.sql(api, "AND")
             else:
                 raise PLCInvalidArgument, "Wrong slice filter %r"%slice_filter

diff --git a/PLC/TagTypes.py b/PLC/TagTypes.py
index 209b61e..d4d4cd7 100644 (file)
--- a/PLC/TagTypes.py
+++ b/PLC/TagTypes.py
@@ -33,13 +33,13 @@ class TagType (Row):
 
     def validate_name(self, name):
         if not len(name):
-            raise PLCInvalidArgument, "node tag type name must be set"
+            raise PLCInvalidArgument, "tag type name must be set"
 
         conflicts = TagTypes(self.api, [name])
         for tag_type in conflicts:
             if 'tag_type_id' not in self or \
                    self['tag_type_id'] != tag_type['tag_type_id']:
-                raise PLCInvalidArgument, "node tag type name already in use"
+                raise PLCInvalidArgument, "tag type name already in use"
 
         return name
 
@@ -72,89 +72,13 @@ class TagTypes(Table):
             elif isinstance(tag_type_filter, dict):
                 tag_type_filter = Filter(TagType.fields, tag_type_filter)
                 sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND")
-            elif isinstance (tag_type_filter, StringTypes):
-                tag_type_filter = Filter(TagType.fields, {'tagname':[tag_type_filter]})
+            elif isinstance(tag_type_filter, (int, long)):
+                tag_type_filter = Filter(TagType.fields, {'tag_type_id':tag_type_filter})
                 sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND")
-            else:
-                raise PLCInvalidArgument, "Wrong node tag type filter %r"%tag_type_filter
-
-        self.selectall(sql)
-# $URL$
-#
-# Thierry Parmentelat - INRIA
-#
-from types import StringTypes
-
-from PLC.Faults import *
-from PLC.Parameter import Parameter
-from PLC.Filter import Filter
-from PLC.Table import Row, Table
-from PLC.Roles import Role, Roles
-
-# xxx todo : deleting a tag type should delete the related nodegroup(s)
-
-class TagType (Row):
-
-    """
-    Representation of a row in the tag_types table.
-    """
-
-    table_name = 'tag_types'
-    primary_key = 'tag_type_id'
-    join_tables = ['node_tag', 'interface_tag', 'slice_tag', 'site_tag', 'person_tag' ]
-    fields = {
-        'tag_type_id': Parameter(int, "Node tag type identifier"),
-        'tagname': Parameter(str, "Node tag type name", max = 100),
-        'description': Parameter(str, "Node tag type description", max = 254),
-        'category' : Parameter (str, "Node tag category", max=64, optional=True),
-        'min_role_id': Parameter(int, "Minimum (least powerful) role that can set or change this attribute"),
-        }
-
-    def validate_name(self, name):
-        if not len(name):
-            raise PLCInvalidArgument, "node tag type name must be set"
-
-        conflicts = TagTypes(self.api, [name])
-        for tag_type in conflicts:
-            if 'tag_type_id' not in self or \
-                   self['tag_type_id'] != tag_type['tag_type_id']:
-                raise PLCInvalidArgument, "node tag type name already in use"
-
-        return name
-
-    def validate_min_role_id(self, role_id):
-        roles = [row['role_id'] for row in Roles(self.api)]
-        if role_id not in roles:
-            raise PLCInvalidArgument, "Invalid role"
-
-        return role_id
-
-class TagTypes(Table):
-    """
-    Representation of row(s) from the tag_types table
-    in the database.
-    """
-
-    def __init__(self, api, tag_type_filter = None, columns = None):
-        Table.__init__(self, api, TagType, columns)
-
-        sql = "SELECT %s FROM tag_types WHERE True" % \
-              ", ".join(self.columns)
-
-        if tag_type_filter is not None:
-            if isinstance(tag_type_filter, (list, tuple, set)):
-                # Separate the list into integers and strings
-                ints = filter(lambda x: isinstance(x, (int, long)), tag_type_filter)
-                strs = filter(lambda x: isinstance(x, StringTypes), tag_type_filter)
-                tag_type_filter = Filter(TagType.fields, {'tag_type_id': ints, 'tagname': strs})
-                sql += " AND (%s) %s" % tag_type_filter.sql(api, "OR")
-            elif isinstance(tag_type_filter, dict):
-                tag_type_filter = Filter(TagType.fields, tag_type_filter)
-                sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND")
-            elif isinstance (tag_type_filter, StringTypes):
-                tag_type_filter = Filter(TagType.fields, {'tagname':[tag_type_filter]})
+            elif isinstance(tag_type_filter, StringTypes):
+                tag_type_filter = Filter(TagType.fields, {'tagname':tag_type_filter})
                 sql += " AND (%s) %s" % tag_type_filter.sql(api, "AND")
             else:
-                raise PLCInvalidArgument, "Wrong node tag type filter %r"%tag_type_filter
+                raise PLCInvalidArgument, "Wrong tag type filter %r"%tag_type_filter
 
         self.selectall(sql)