def getDefaultCallbacks(ifaceName, lobby, data):
from exchangeapi.IfaceUtils import IfaceNotFound
try:
return filter(None, [getIface(ifaceName).defaultCallback])
except IfaceNotFound as msg:
debug_utils.LOG_ERROR(msg)
return []
def constructRequestOb(transformedRequest):
clientRequestob, serverRequestob = [], []
viewClientRequestob, viewServerRequestob = [], []
def fillifaces(ifacedict1, ifacedict2, ifacename, obtype,
ifacedata):
if getOblocation(ifacename,
listFromId(obtype)) == OB_LOCATION.CLIENT:
ifacedict1[ifacename] = ifacedata
else:
ifacedict2[ifacename] = ifacedata
def fillob(ifacedict, requestob, obid, obtype):
if ifacedict:
requestob.append([
ifacedict,
joinIDTypeList(listFromId(obid), listFromId(obtype))
])
for obid in transformedRequest:
for obtype in transformedRequest[obid]:
clientObtypeIfaces, serverObtypeIfaces = {}, {}
viewClientObypteIfaces, viewServerObtypeIfaces = {}, {}
for parent, ifacenames in transformedRequest[obid][
obtype].iteritems():
clientIfaces, serverIfaces = {}, {}
viewClientIfaces, viewServerIfaces = {}, {}
for ifacename, data in ifacenames.iteritems():
iface = getIface(ifacename)
ifacedata = dict(
((attr, value)
for attr, value in data.iteritems()
if attr in iface.attr))
if len(ifacenames) > 1:
ifacename = '%s:%s' % (parent, ifacename)
if INDEXTOMETHOD[
method] == 'edit' and not ifacedata and parent != ifacename:
fillifaces(viewClientIfaces, viewServerIfaces,
ifacename, obtype, ifacedata)
else:
fillifaces(clientIfaces, serverIfaces,
ifacename, obtype, ifacedata)
clientObtypeIfaces.update(clientIfaces)
serverObtypeIfaces.update(serverIfaces)
viewClientObypteIfaces.update(viewClientIfaces)
viewServerObtypeIfaces.update(viewServerIfaces)
fillob(clientObtypeIfaces, clientRequestob, obid, obtype)
fillob(serverObtypeIfaces, serverRequestob, obid, obtype)
fillob(viewClientObypteIfaces, viewClientRequestob, obid,
obtype)
fillob(viewServerObtypeIfaces, viewServerRequestob, obid,
obtype)
return (clientRequestob, serverRequestob, viewClientRequestob,
viewServerRequestob)
def generateEvent(method, eventName, ifaceName, idTypeList, account, ob, prevob = None):
ifaceNameList = ifaceName.split(':')
if method == 'view' and len(ifaceNameList) > 1 and len(set(ifaceNameList)) > 1:
return
try:
eventManager(Event(eventName, getIface(ifaceName), idTypeList, account, ob, prevob))
if LOG_EVENT:
LOG_MX_DEV('Event {0} for iface {1} generated'.format(eventName, ifaceName))
except IfaceNotFound as msg:
LOG_ERROR('Event {0} for iface {1} generation error: {2}'.format(eventName, ifaceName, msg))
def __separateBuilder(self, ifacename, parentIfacename, ifacedata,
idTypeList, result):
idList, typeList = splitIDTypeList(idTypeList)
ids = idFromList(idList)
types = idFromList(typeList)
piface = getIface(parentIfacename)
parentdata = {}
for attr in piface.attr:
attrdata = ifacedata.get(attr, None)
if attrdata is not None:
parentdata[attr] = attrdata
result.setdefault(ids, {}).setdefault(types, {}).setdefault(
ifacename, {}).setdefault(parentIfacename, {}).update(parentdata)
for parentIfacename in getIface(parentIfacename).parent:
self.__separateBuilder(ifacename, parentIfacename, ifacedata,
idTypeList, result)
return
def setToCache(idTypeList, ifaceName, data, event=True):
global EXPIRING_CALLBACKS
if not INITIALIZED:
LOG_ERROR('Cache is not initialized')
return False
else:
try:
cacheType = getIface(ifaceName).cacheType
except IfaceNotFound:
cacheType = CACHE_TYPE.FULL_CACHE
if cacheType == CACHE_TYPE.NONE:
return False
try:
from exchangeapi.AdapterUtils import getOblocationDBObject
_, typeList = splitIDTypeList(idTypeList)
expiringTime = getOblocationDBObject(ifaceName,
typeList).expiringTime
except:
expiringTime = None
if expiringTime:
EXPIRING_CALLBACKS.append(
BigWorld.callback(
expiringTime,
partial(actualizeCacheData, idTypeList, ifaceName)))
cacheID = generateID(idTypeList, ifaceName)
memCacheUtility.setToCache(cacheID, data)
if cacheType == CACHE_TYPE.FULL_CACHE:
cacheUtility.setToCache(
cacheID if cacheUtility.ID_TYPE == int else generateUUID(
idTypeList, ifaceName), data)
if event:
from exchangeapi.EventUtils import generateEvent
generateEvent('', 'settocache', ifaceName, idTypeList, None, data,
None)
return True
def sendDataToUICallbacks(headers, respdata, callback, ifacehandler = None, data = UI_CALLBACKS, fromserver = False, broadcast = True, proccesedIfaces = None):
data = dict(data)
from Helpers.ExchangeObBuilder import ExchangeObBuilder, cacheIFaceData, responseEventGenerate
from Helpers.cache import getFromCache
proccesedIfaces = proccesedIfaces or dict()
if callback:
ifacehandler.addResponseCallbackToQueue(partial(ifacehandler.call_1, callback, convertIfaceDataForUI(respdata), 0))
for ifaces, idTypeList in respdata:
ids, types = map(idFromList, splitIDTypeList(idTypeList))
for ifacename in ifaces:
if ifacename in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
ifacedata = {ifacename: ifaces[ifacename]}
idata = [[ifacedata, idTypeList]]
iface = getIface(ifacename)
if fromserver:
from Helpers.ExchangeObBuilder import processIFaceData
processIFaceData([int(not IS_CLIENT), METHODTOINDEX['view']], idata)
responseEventGenerate(headers, idata)
cacheIFaceData(idata)
if ifacedata[ifacename]:
for c in getDefaultCallbacks(ifacename, ifacehandler, data):
addUICallback([[{ifacename: True}, idTypeList]], c, ifacehandler, data)
data.update(UI_CALLBACKS)
if iface.parent:
def constructed(ifacehandler, fromserver, broadcast, proccesedIfaces, responseob):
if responseob[-1] == ErrorCodes.SUCCESS:
responseEventGenerate([int(not consts.IS_CLIENT), METHODTOINDEX['edit']], responseob[1])
sendDataToUICallbacks(responseob[0], responseob[1], None, ifacehandler, data, fromserver, broadcast, proccesedIfaces)
return
requestob = [[int(consts.IS_CLIENT)], [[{ifacename: {}}, idTypeList]], METHODTOINDEX['view']]
builder = ExchangeObBuilder(requestob, False)
builder.setFinishCallback(partial(constructed, ifacehandler, False, broadcast, proccesedIfaces))
builder.build()
continue
elif ifacedata[ifacename]:
for c in getDefaultCallbacks(ifacename, ifacehandler, data):
addUICallback([[{ifacename: True}, idTypeList]], c, ifacehandler, data)
data.update(UI_CALLBACKS)
proccesedIfaces.setdefault(ids, {}).setdefault(types, set([])).update([ifacename])
callbacks = set(data.get(ids, {}).get(types, {}).get(ifacename, []))
if callbacks:
for parentname in iface.parent:
PARENT_INTERFACES.setdefault(ids, {}).setdefault(types, set([])).update([ifacename])
for item in callbacks:
if item != callback:
if broadcast and ifacehandler:
debug_utils.LOG_DEBUG('UICallbackUtils:Iface:response', idata, item)
convertedIDTypeList = convertIDTypeListForUI(idTypeList)
if not convertedIDTypeList:
obid = None
obtype = None
else:
obid = convertedIDTypeList[0][0]
obtype = convertedIDTypeList[0][1]
ifacehandler.addResponseCallbackToQueue(partial(ifacehandler.call_1, item, [[ifacedata, obid, obtype]] if idTypeList is not None and len(idTypeList) < 2 else [[ifacedata, convertedIDTypeList]], 0))
if not fromserver and ifacedata[ifacename]:
addUICallback(idata, item, ifacehandler, data)
elif not ifacedata[ifacename]:
removeUICallback(idata, item, ifacehandler, data)
if broadcast and ifacehandler:
for parentname in iface.parent:
if parentname in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
piface = getIface(parentname)
cacheddata = getFromCache(idTypeList, parentname) or {}
parentdata = dict(((attr, ifaces[ifacename].get(attr, cacheddata.get(attr, None))) for attr in piface.attr))
if parentdata:
iparentdata = [[{parentname: parentdata}, idTypeList]]
responseEventGenerate([int(consts.IS_CLIENT), METHODTOINDEX['edit']], iparentdata)
sendDataToUICallbacks(headers, iparentdata, None, ifacehandler, data, fromserver, broadcast, proccesedIfaces)
pnames = list(PARENT_INTERFACES.get(ids, {}).get(types, set([])))
for pname in pnames:
if pname in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
def constructed(ifacehandler, broadcast, proccesedIfaces, responseob):
if responseob[-1] == ErrorCodes.SUCCESS:
responseEventGenerate([int(consts.IS_CLIENT), METHODTOINDEX['edit']], responseob[1])
sendDataToUICallbacks(responseob[0], responseob[1], None, ifacehandler, data, False, broadcast, proccesedIfaces)
return
requestob = [[int(consts.IS_CLIENT)], [[{pname: {}}, idTypeList]], METHODTOINDEX['view']]
builder = ExchangeObBuilder(requestob, False)
builder.setFinishCallback(partial(constructed, ifacehandler, broadcast, proccesedIfaces))
builder.build()
return
def __init__(self, ifacename):
self._ifacename = ifacename
self._iface = getIface(ifacename)