def cacheIFaceData(respdata):
    for data, idTypeList in respdata:
        for ifacename in data:
            if data[ifacename]:
                setToCache(idTypeList, ifacename, data[ifacename])
            else:
                deleteFromCache(idTypeList, ifacename)
 def data():
     for planeID in planeIDs:
         idTypeList = [[planeID, 'plane']]
         deleteFromCache(idTypeList, ifacename)
         ids, types = map(idFromList, splitIDTypeList(idTypeList))
         if accountUI and set(UI_CALLBACKS.get(ids, {}).get(types, {}).get(ifacename, [])):
             yield [{ifacename: {}}, idTypeList]
Example #3
0
def _updateRentedPlane(planeID):
    ifacename = 'IRent'
    idTypeList = [[planeID, 'plane']]
    ids, types = map(idFromList, splitIDTypeList(idTypeList))
    deleteFromCache(idTypeList, ifacename)
    if set(UI_CALLBACKS.get(ids, {}).get(types, {}).get(ifacename, [])):
        accountUI = g_windowsManager.getAccountUI()
        if accountUI:
            accountUI.viewIFace([[{ifacename: {}}, idTypeList]])
        else:
            LOG_ERROR('accountUI is not ready. IRent not called')
    if planeID in RENT_CALLBACKS:
        BigWorld.cancelCallback(RENT_CALLBACKS[planeID])
    RENT_CALLBACKS[planeID] = BigWorld.callback(UPDATER_PERIOD, partial(_updateRentedPlane, planeID))
 def delete(self, account, requestID, idTypeList, **kw):
     from exchangeapi.EventUtils import generateEvent
     ob = getFromCache(idTypeList, self._iface.ifacename)
     if ob:
         LOG_TRACE('Executing callback for package id: {0}'.format(
             idTypeList[0][0]))
         import BigWorld
         from Account import PlayerAccount
         player = BigWorld.player()
         if player and player.__class__ == PlayerAccount:
             popMappedCallback(idTypeList[0][0],
                               player.processIfaceData)(None, None,
                                                        ob['data'])
             deleteFromCache(idTypeList, self._iface.ifacename)
             generateEvent('delete', 'delete', self._iface.ifacename,
                           idTypeList, account, {}, ob)
     return {}
 def cachedata(ifacesFromCache):
     for obid in transformedResponse:
         for obtype in transformedResponse[obid]:
             idTypeList = joinIDTypeList(listFromId(obid),
                                         listFromId(obtype))
             idList, typeList = splitIDTypeList(idTypeList)
             ids = idFromList(idList)
             types = idFromList(typeList)
             for parentName, ifaces in transformedResponse[obid][
                     obtype].iteritems():
                 for ifacename, attrs in ifaces.iteritems():
                     if not ifacesFromCache.get(ids, {}).get(
                             types, {}).get(ifacename, False):
                         if attrs:
                             setToCache(idTypeList, ifacename,
                                        attrs)
                         else:
                             deleteFromCache(idTypeList, ifacename)
                     else:
                         transformedResponse[obid][obtype][
                             parentName][ifacename] = getFromCache(
                                 idTypeList, ifacename) or {}
def _invalidate(event):
    from Helpers.cache import deleteFromCache
    for pid in event.ob['planes']:
        idTypeList = [event.idTypeList[0], [pid, 'plane']]
        deleteFromCache(idTypeList, 'IPlayerShortPlaneStats')
        deleteFromCache(idTypeList, 'IPlayerPlaneStats')

    deleteFromCache(event.idTypeList, event.iface.ifacename)