Python PersistentMapping.PersistentMapping类代码示例

class TransformDataProvider(Implicit):
    """ Base class for data providers """
    security = ClassSecurityInfo()
    security.declareObjectPublic()

    def __init__(self):
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()

        self.config.update({'inputs' : {} })
        self.config_metadata.update({
            'inputs' : {
                'key_label' : '',
                'value_label' : '',
                'description' : ''}
            })

    security.declarePublic('setElement')
    def setElement(self, inputs):
        """ inputs - dictionary, but may be extended to new data types"""
        self.config['inputs'].update(inputs)

    def delElement(self, el):
        """ el - dictionary key"""
        del self.config['inputs'][el]

    security.declarePublic('getElements')
    def getElements(self):
        """ Returns mapping """
        return self.config['inputs']

    security.declarePublic('getConfigMetadata')
    def getConfigMetadata(self):
        """ Returns config metadata """
        return self.config_metadata['inputs']

    def __init__(self):
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()

        self.config.update({'inputs' : {} })
        self.config_metadata.update({
            'inputs' : {
                'key_label' : '',
                'value_label' : '',
                'description' : ''}
            })

    def test_mapping_copy(self):

        a = PersistentMapping(dict(a=3, b=5))
        b = a.copy()
        c = copy.copy(a)

        assert a == b
        assert a == c
        assert a is not b
        assert a is not c
        assert b is not c

        del a["a"]
        assert b["a"]  # NOT impacted
        assert c["a"]  # NOT impacted

    def __init__(self):
        """ We need to redefine config and config_metadata
        in base class.
        """
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()
        
        self.config.update({ 'inputs' : self.defaultEmoticons()})

        self.config_metadata.update({
            'inputs' : {
                'key_label' : 'emoticon code', 
                'value_label' : 'image name', 
                'description' : 'Emoticons to images mapping'}
            })

 def __init__(self, id,title=''):
     '''Initialize an instance of the class'''            
     self.id=id            
     self.sampleImage = ''
     self.abstract = ''
     self.keywords = ''        
     self.uniqueName = ''
     self.geometryField = ''
     self.geometryType = ''
     self.title = id
     self.wfsSRS = ''
     self.wmsStyleName = ''
     self.wfsBoundingBox = ''
     self.fields = ''
     self.source = ''
     self.error = ''
     self.wmsQueryable = ''
     self.wmsName = ''
     self.wfsName = ''
     self.wmsSRS = ''
     self.wmsTitle = ''
     self.hasWFSLayer = False
     self.wmsBoundingBox = ''
     self.describeFeatureResponse = ''
     self.availablePermissions = ['Render','Extract']
     self.security = PersistentMapping() # e.g {'Manager':{'Render':0,'Extract':1}}        
     self.wmsXML = ""
     self.wfsXML = ""
     self.organization = ""
     self.reindexObject()
     self._p_changed = 1

 def __init__(self, id):
     Content.__init__(self, id)
     Query.__init__(self)
     self.shownFields = PersistentMapping()
     self.shownResultsFields = PersistentMapping()
     # by default we only show fulltext search
     # and a couple of resultfields
     self.shownFields['fulltext'] = True
     self.shownResultsFields['link'] = True
     self.shownResultsFields['ranking'] = True
     self.shownResultsFields['resultcount'] = True
     self.shownResultsFields['icon'] = True
     self.shownResultsFields['date'] = True
     self.shownResultsFields['textsnippet'] = True
     self.shownResultsFields['thumbnail'] = True
     self.shownResultsFields['breadcrumbs'] = True

 def __init__(self,default_role,NoLocalRoles):
     self.id='nisAuthSource'
     self.default_role=default_role
     self.NoLocalRoles=NoLocalRoles
     self.data=PersistentMapping()
     self.manage_addUserForm=DTMLFile('manage_addNISUserForm',globals())
     self.manage_editUserForm=DTMLFile('manage_editNISUserForm',globals()) #not used.  No way to plug it into exUserFolder.py

class Map(SimpleItem):
    def __init__(self, id):
        self.id = id
        self.channels = PersistentMapping()
        self.policy = defaultPolicy

    def setPolicy(self, name):
        self.policy = lookupPolicy(name, defaultPolicy)

    def setPriority(self, channel, pri):
        if not isinstance(channel, Channel):
            id = channel.id
        else:
            id = channel

        channel = self.channels[id]
        channel['priority'] = int(pri)


    def addChannel(self, channel, **kwargs):
        enabled  = kwargs.get('enabled', 1)
        priority = kwargs.get('priority', 0)

        self.channels[channel.id] = {'channel' : channel,
                                     'enabled' : enabled,
                                     'priority': priority,
                                     }
    def Channels(self):
        return self.channels.values()

    def __init__(self, id=None):
        BaseContent.__init__(self,'portal_csvreplicatatool')
        self.setTitle('')

        ##code-section constructor-footer #fill in your manual code here
        self.setTitle('CSV Replicator tool')
        self.replicabletypes = PersistentMapping()
        self.handlers = {}

    def __init__(self):
        """ We need to redefine config and config_metadata
        in base class.
        """
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()

        self.config.update({"inputs": self.defaultEmoticons()})

        self.config_metadata.update(
            {
                "inputs": {
                    "key_label": "emoticon code",
                    "value_label": "image name",
                    "description": "Emoticons to images mapping",
                }
            }
        )

class EmoticonDataProvider(TransformDataProvider):
    def __init__(self):
        """ We need to redefine config and config_metadata
        in base class.
        """
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()

        self.config.update({"inputs": self.defaultEmoticons()})

        self.config_metadata.update(
            {
                "inputs": {
                    "key_label": "emoticon code",
                    "value_label": "image name",
                    "description": "Emoticons to images mapping",
                }
            }
        )

    def defaultEmoticons():
        emoticons = {
            ":)": '<img src="smiley_smile.png" alt=":)" title="Smile" />',
            ":(": '<img src="smiley_sad.png" alt=":(" title="Sad" />',
            "8-)": '<img src="smiley_cool.png" alt="8)" title="Cool" />',
            ":D": '<img src="smiley_lol.png" alt=":D" title="Big grin" />',
            ":|": '<img src="smiley_skeptic.png" alt=":|" title="Skeptic" />',
            ":o": '<img src="smiley_surprised.png" alt=":o" title="Surprised" />',
            ":P": '<img src="smiley_tongue.png" alt=":P" title="Tongue-in-cheek" />',
            ";)": '<img src="smiley_wink.png" alt=";)" title="Wink" />',
            ":-)": '<img src="smiley_smile.png" alt=":)" title="Smile" />',
            ":-(": '<img src="smiley_sad.png" alt=":(" title="Sad" />',
            ":-D": '<img src="smiley_lol.png" alt=":D" title="Big grin" />',
            ":-|": '<img src="smiley_skeptic.png" alt=":|" title="Skeptic" />',
            ":-o": '<img src="smiley_surprised.png" alt=":o" title="Surprised" />',
            ":-P": '<img src="smiley_tongue.png" alt=":P" title="Tongue-in-cheek" />',
            ";-)": '<img src="smiley_wink.png" alt=";)" title="Wink" />',
        }
        return emoticons

    defaultEmoticons = staticmethod(defaultEmoticons)

class EmoticonDataProvider(TransformDataProvider):
    def __init__(self):
        """ We need to redefine config and config_metadata
        in base class.
        """
        self.config = PersistentMapping()
        self.config_metadata = PersistentMapping()
        
        self.config.update({ 'inputs' : self.defaultEmoticons()})

        self.config_metadata.update({
            'inputs' : {
                'key_label' : 'emoticon code', 
                'value_label' : 'image name', 
                'description' : 'Emoticons to images mapping'}
            })

    def defaultEmoticons():
        emoticons = { ':)' : '<img src="smiley_smile.png" alt=":)" title="Smile" />'
                    , ':(' : '<img src="smiley_sad.png" alt=":(" title="Sad" />'
                    , '8-)' : '<img src="smiley_cool.png" alt="8)" title="Cool" />'
                    , ':D' : '<img src="smiley_lol.png" alt=":D" title="Big grin" />'
                    , ':|' : '<img src="smiley_skeptic.png" alt=":|" title="Skeptic" />'
                    , ':o' : '<img src="smiley_surprised.png" alt=":o" title="Surprised" />'
                    , ':P' : '<img src="smiley_tongue.png" alt=":P" title="Tongue-in-cheek" />'
                    , ';)' : '<img src="smiley_wink.png" alt=";)" title="Wink" />'
                    , ':-)' : '<img src="smiley_smile.png" alt=":)" title="Smile" />'
                    , ':-(' : '<img src="smiley_sad.png" alt=":(" title="Sad" />'
                    , ':-D' : '<img src="smiley_lol.png" alt=":D" title="Big grin" />'
                    , ':-|' : '<img src="smiley_skeptic.png" alt=":|" title="Skeptic" />'
                    , ':-o' : '<img src="smiley_surprised.png" alt=":o" title="Surprised" />'
                    , ':-P' : '<img src="smiley_tongue.png" alt=":P" title="Tongue-in-cheek" />'
                    , ';-)' : '<img src="smiley_wink.png" alt=";)" title="Wink" />'
                    }
        return emoticons
    defaultEmoticons=staticmethod(defaultEmoticons)

class BdrAuthorizationMiddleware(SimpleItem):

    recheck_interval = 300

    def __init__(self, url):
        self.recheck_interval = 300
        self.lockedDownCollections = PersistentMapping()

    def setServiceRecheckInterval(self, seconds):
        self.recheck_interval = seconds

    @ram.cache(lambda *args, **kwargs: args[2] + str(time() // kwargs['recheck_interval']))
    def getUserCollectionPaths(self, username, recheck_interval=recheck_interval):
        logger.debug("Get companies from middleware for ecas user: %s" % username)
        accessiblePaths = self.FGASRegistryAPI.getCollectionPaths(username)
        return accessiblePaths

    def authorizedUser(self, username, path):
        if self.lockedCollection(path):
            logger.warning("This collection is locked down: %s!" % path)
            return False
        accessiblePaths = self.getUserCollectionPaths(username, recheck_interval=self.recheck_interval)
        if path in accessiblePaths.get('paths'):
            return "RW"
        if path in accessiblePaths.get('prev_paths'):
            return "RO"

    def lockDownCollection(self, path, user):
        if path not in self.lockedDownCollections:
            self.lockedDownCollections[path] = None
        self.lockedDownCollections[path] = {'state': 'locked',
                                            'ts': time(),
                                            'user': user}

    def unlockCollection(self, path, user):
        if path not in self.lockedDownCollections:
            # log unlock without lock
            self.lockedDownCollections[path] = None
        self.lockedDownCollections[path] = {'state': 'unlocked',
                                            'ts': time(),
                                            'user': user}

    def lockedCollection(self, path):
        lockedItem = self.lockedDownCollections.get(path)
        return lockedItem and lockedItem['state'] == 'locked'

class Query(object):

    def __init__(self):
        self.searchValues = PersistentMapping()

    def getSearchSchema(self):
        return getUtility(IFindService).getSearchSchema()

    def getResultsSchema(self):
        return getUtility(IFindService).getResultsSchema()

    def getSearchFields(self):
        return self.getSearchSchema().getFields()

    def getResultFields(self):
        return self.getResultsSchema().getFields()

    def getCriterionValue(self, name):
        searchSchema = self.getSearchSchema()
        if searchSchema.hasField(name):
            return self.searchValues.get(name, None)
        else:
            raise ValueError(
                u'No field named %s defined in search schema' %
                name)

    def deleteCriterionValue(self, name):
        searchSchema = self.getSearchSchema()
        if searchSchema.hasField(name):
            if name in self.searchValues:
                del self.searchValues[name]

    def setCriterionValue(self, name, value):
        searchSchema = self.getSearchSchema()
        if searchSchema.hasField(name):
            self.searchValues[name] = value
        else:
            raise ValueError(
                u'No field named %s defined in search schema' %
                name)

class Themes(SimpleItem, session_manager):
    """ Themes """

    meta_type = THEMES_METATYPE
    product_name = NAAYATHESAURUS_PRODUCT_NAME
    icon = "misc_/NaayaThesaurus/themes.gif"

    manage_options = (
        {"label": "Basic properties", "action": "properties_html"},
        {"label": "Management", "action": "themes_html"},
        {"label": "Import", "action": "import_html"},
        {"label": "Statistics", "action": "statistics_html"},
        {"label": "Undo", "action": "manage_UndoForm"},
    )

    security = ClassSecurityInfo()

    def __init__(self, id, title):
        """ constructor """
        self.id = id
        self.title = title
        self.themes = PersistentMapping()

    # basic properties
    security.declareProtected(view_management_screens, "manageBasicProperties")

    def manageBasicProperties(self, title="", REQUEST=None):
        """ manage basic properties for Themes """
        self.title = title
        self._p_changed = 1
        if REQUEST:
            self.setSessionInfoTrans("Saved changes.")
            return REQUEST.RESPONSE.redirect("properties_html")

    # themes management
    def __add_theme(self, theme_id, langcode, name):
        # create a new item
        item = ThemeItem(theme_id, langcode, name)
        self.themes[(theme_id, langcode)] = item
        self.catalog.CatalogObject(item)

    def __update_theme(self, theme_id, old_theme_id, langcode, old_langcode, name):
        # modify an item
        item = self.themes.get((old_theme_id, old_langcode))
        if item is not None:
            self.__delete_theme((old_theme_id, old_langcode))
        self.__add_theme(theme_id, langcode, name)

    def __delete_theme(self, ids):
        # delete 1 or more items
        if type(ids) != type((1, 1)):
            ids = th_utils().utConvertToList(ids)
        else:
            ids = [ids]
        collection = self.get_themes()

        for id in ids:
            self.catalog.UncatalogObject(collection[id])
            del collection[id]

    # theme constraints
    security.declareProtected(view_management_screens, "checkTheme")

    def checkTheme(self, theme_id):
        """ """
        if theme_id in self.getThemeRelationsFolder().getDistinctThemes():
            return 1
        return 0

    security.declareProtected(view_management_screens, "getIdsList")

    def getIdsList(self, ids, all=0):
        """ """
        if all:
            return self.themes.keys()
        return th_utils().getIdsList(ids)

    # themes getters
    def get_themes(self):
        # get all themes
        return self.themes

    def get_themes_sorted(self):
        # get all themes sorted
        return th_utils().utSortObjsListByAttr(self.themes.values(), "langcode", 0)

    def get_theme_by_id(self, id):
        # get an item
        try:
            return self.themes[id]
        except:
            return None

    def get_theme_item_data(self, theme_id, langcode, orig_theme_id, orig_langcode, theme_name):
        # get an item data
        item = self.get_theme_by_id((orig_theme_id, orig_langcode))
        if item is not None:
            if theme_name is None:
                theme_name = item.theme_name
            return ["update", theme_id, langcode, theme_name, orig_theme_id, orig_langcode]
#.........这里部分代码省略.........