From 00b458601d8f318b617b43d11cb4fdb93e89967c Mon Sep 17 00:00:00 2001 From: Daniel Hokka Zakrisson Date: Fri, 15 Oct 2010 10:12:41 -0400 Subject: [PATCH] Be consistent in the API. --- PLC/AddressTypes.py | 8 ++++ PLC/Addresses.py | 2 +- PLC/ConfFiles.py | 2 +- PLC/EventObjects.py | 5 +- PLC/Events.py | 4 +- PLC/Ilinks.py | 4 +- PLC/InitScripts.py | 8 ++++ PLC/InterfaceTags.py | 4 +- PLC/Keys.py | 4 +- PLC/Leases.py | 5 +- PLC/Messages.py | 4 +- PLC/Methods/DeleteAddress.py | 2 +- PLC/NodeGroups.py | 8 ++++ PLC/NodeTags.py | 4 +- PLC/Nodes.py | 6 +-- PLC/PCUProtocolTypes.py | 10 +--- PLC/PCUTypes.py | 4 +- PLC/PCUs.py | 4 +- PLC/Peers.py | 8 ++++ PLC/PersonTags.py | 4 +- PLC/Persons.py | 6 +-- PLC/Roles.py | 8 ++++ PLC/Sessions.py | 8 ++++ PLC/SiteTags.py | 4 +- PLC/Sites.py | 6 +-- PLC/SliceTags.py | 4 +- PLC/Slices.py | 6 +-- PLC/TagTypes.py | 90 +++--------------------------------- 28 files changed, 96 insertions(+), 136 deletions(-) diff --git a/PLC/AddressTypes.py b/PLC/AddressTypes.py index 74bf0f7..15b0ea1 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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) -- 2.43.0