def ShowContract(*args):
submit_metric('igb_show_contract')
if len(args) < 1:
log.LogError(
'CCPEVE.ShowContract received insufficient arguments. This method requires a SolarSystemID and a ContractID.'
)
return
if len(args) == 1:
ids = args[0].split('//')
if len(ids) < 2:
log.LogError(
'CCPEVE.ShowContract received old-style insufficient arguments. This method requires a SolarSystemID and a ContractID.'
)
return
contractID = ids[1]
solarSystemID = ids[0]
else:
contractID = args[1]
solarSystemID = args[0]
try:
contractID = int(contractID)
except:
log.LogError(
'CCPEVE.ShowContract failed to convert contractID to an integer:',
contractID)
return
solarSystemID = browserutil.SanitizedSolarsystemID(solarSystemID)
if contractID is None or solarSystemID is None:
log.LogError(
'CCPEVE.ShowContract received invalid contract or solarsystem IDs; contractID:',
contractID, 'solarSystemID:', solarSystemID)
return
sm.GetService('contracts').ShowContract(contractID)
def CreateComponent(self, name, state):
"""
Create a UIDesktop component and return it. This performs a little bit of namespace magic
which looks upa UIDesktop within the 'screens' namespace. A registration mechanic would be better.
We cannot define an absolute list in the core code, to cover both Eve and Wod.
"""
component = UIDesktopComponent()
if 'uiDesktopName' in state:
component.uiDesktopName = str(state['uiDesktopName'])
component.renderTarget = blue.resMan.GetResource(
'dynamic:/%s' % component.uiDesktopName)
if component.renderTarget is None:
log.LogError(
'Failed to acquire a render target texture for %s' %
component.uiDesktopName)
try:
import screens
component.width, component.height, component.format, component.liveUpdates, component.autoMipMap, component.updateFunction = getattr(
screens, component.uiDesktopName)
except (AttributeError, ImportError):
log.LogException()
if not component.liveUpdates:
component.active = False
component.renderJob = trinity.CreateRenderJob()
else:
log.LogError('No uiDesktopName set')
self.uiDesktops.append(component)
return component
def LocalSvcCall(self, args):
import htmlwriter
import service
kw = htmlwriter.PythonizeArgs(args)
if 'service' not in kw:
log.LogError('Invalid LocalSvc args:', args, ' (missing service)')
return
sv = kw['service']
del kw['service']
if 'method' not in kw:
log.LogError('Invalid LocalSvc args:', args, ' (missing method)')
return
method = kw['method']
del kw['method']
svc = sm.GetService(sv)
access = svc.__exportedcalls__.get(method, [])
if access and type(access) in (types.ListType, types.TupleType):
access = access[0]
elif type(access) == types.DictType:
access = access.get('role', 0)
else:
access = 0
if access & service.ROLE_IGB:
apply(getattr(svc, method), (), kw)
else:
log.LogError('Invalid LocalSvc args:', args,
' (method not allowed)')
def CheckAds(self, hidden = False):
alwaysShowAd = False
try:
extraParam = sm.GetService('patch').GetWebRequestParameters()
if settings.public.ui.Get('usernames') is None and sm.GetService('patch').GetClientAffiliateID() != '':
alwaysShowAd = True
adUrl = WEB_EVE + '/ads.asp?%s' % extraParam
sm.GetService('loading').LogInfo('ad URL:', adUrl)
ads = corebrowserutil.GetStringFromURL(adUrl).read()
except Exception as e:
log.LogError('Failed to fetch ads', e)
sys.exc_clear()
self.CloseAd()
return
ads = [ ad for ad in ads.split('\r\n') if ad ]
for ad in ads:
imgpath, url = ad.split('|')
didShowAd = settings.public.ui.Get(imgpath + 'Ad', 0)
if not didShowAd or alwaysShowAd:
try:
self.OpenAd(imgpath, url, hidden)
except Exception as e:
log.LogError('Failed to display ad', e, imgpath, url)
sys.exc_clear()
return
def ShowRouteTo(self, args):
fromto = args.split('::')
if len(fromto) not in (1, 2):
log.LogError(
'failed to convert string to id in Browser:ShowRouteTo. Args:',
args)
return
for i in fromto:
try:
id = int(i)
except:
log.LogError(
'failed to convert string to id in Browser:ShowRouteTo. Args:',
args)
return
if eve.session.stationid:
sm.GetService('station').CleanUp()
destinationID = int(fromto[0])
sourceID = None
if len(fromto) == 2:
sourceID = int(fromto[1])
sm.GetService('viewState').ActivateView('starmap',
interestID=sourceID
or session.regionid,
drawRoute=(sourceID,
destinationID))
def LoadModel(self, fileName=None, loadedModel=None):
shipType = cfg.invtypes.Get(self.typeID)
if shipType is not None:
g = cfg.graphics.GetIfExists(shipType.graphicID)
self.raceID = getattr(g, 'gfxRaceID', None)
if fileName is None and loadedModel is None:
if self.typeID is None:
return
if shipType.graphicID is not None:
if shipType.Graphic():
fileName = shipType.GraphicFile()
if not (fileName.lower().endswith('.red')
or fileName.lower().endswith('.blue')):
filename_and_turret_type = split(fileName, ' ')
fileName = filename_and_turret_type[0]
self.LogInfo('LoadModel', fileName)
if fileName is None and loadedModel is None:
self.LogError(
'Error: Object type %s has invalid graphicFile, using graphicID: %s'
% (self.typeID, cfg.invtypes.Get(self.typeID).graphicID))
return
model = None
if fileName is not None and len(fileName) and loadedModel is None:
try:
model = blue.resMan.LoadObject(fileName)
except:
model = None
sys.exc_clear()
else:
model = loadedModel
if not model:
log.LogError('Could not load model for spaceobject. FileName:',
fileName, ' id:', self.id, ' typeID:',
getattr(self, 'typeID', '?'))
log.LogError('Type is:', cfg.invtypes.Get(self.typeID).typeName)
return
self.model = model
if not hasattr(model, 'translationCurve'):
self.LogError('LoadModel - Model in', fileName,
"doesn't have a translationCurve.")
else:
model.translationCurve = self
model.rotationCurve = self
model.name = '%d' % self.id
if hasattr(model, 'useCurves'):
model.useCurves = 1
if self.model is not None and self.HasBlueInterface(
self.model, 'IEveSpaceObject2'):
scene = sm.StartService('sceneManager').GetRegisteredScene(
'default')
if scene is not None:
scene.objects.append(self.model)
else:
raise RuntimeError('Invalid object loaded by spaceObject: %s' %
str(self.model))
sm.StartService('FxSequencer').NotifyModelLoaded(self.id)
self.modelLoadedEvent.set()
def _Delete(self, item):
if item is not None:
stamp, callback, model, pool = item
if model is None:
log.LogError('ExplosionManager::_Delete item has no model')
if pool is None:
log.LogError('ExplosionManager::_Delete item has no pool')
if callback is not None:
callback(model)
model.Stop()
model.loadedCallback = None
pool.Push(model)
pool.DecRef(1)
def _StartXMLRPCServer(self):
"""Start the XML-RPC server."""
self.rpcserver = None
# win32 allows big ints to wrap 64k and produce undesired
# port bindings. sanity check.
if self.bind_port < 1 or self.bind_port > 65535:
log.LogError('bad port number %d' % self.bind_port)
return
try:
rpcserver = service.Server(self.bind_host, self.bind_port)
except socket.error, e:
log.LogError('XML-RPC Server startup socket error: %s' % str(e))
return
def GetZoomValues(self, model, thread):
rad = 300
camera = self.sceneManager.GetRegisteredCamera(self.name)
trinity.WaitForResourceLoads()
rad = model.GetBoundingSphereRadius()
center = model.boundingSphereCenter
localBB = model.GetLocalBoundingBox()
if localBB[0] is None or localBB[1] is None:
log.LogError(
"Failed to get bounding info for ship. Odds are the ship wasn't loaded properly."
)
localBB = (trinity.TriVector(0, 0, 0), trinity.TriVector(0, 0, 0))
model.translationCurve = trinity.TriVectorCurve()
negativeCenter = (-center[0], -localBB[0].y + 180.0, -center[2])
model.translationCurve.value = negativeCenter
cameraparent = self.GetCameraParent()
if cameraparent.translationCurve is not None:
keyValue = cameraparent.translationCurve.keys[1].value
if self.staticEnv:
keyValue = (keyValue[0], -localBB[0].y + 180.0, keyValue[2])
cameraparent.translationCurve.keys[0].value = keyValue
key1Value = cameraparent.translationCurve.keys[1].value
key1Value = (key1Value[0], -localBB[0].y + 180.0, key1Value[2])
cameraparent.translationCurve.keys[1].value = key1Value
cameraparent.translationCurve.start = blue.os.GetSimTime()
zoomMultiplier = 1.0
aspectRatio = trinity.GetAspectRatio()
if aspectRatio > 1.6:
zoomMultiplier = aspectRatio / 1.6
self.minZoom = (rad + camera.frontClip + 50) * zoomMultiplier
self.maxZoom = 2050.0
self.layer.maxZoom = self.maxZoom
self.layer.minZoom = self.minZoom
return (rad + camera.frontClip) * 2
def ShowPreview(typeID):
safeTypeID = browserutil.SanitizedTypeID(int(typeID))
if safeTypeID is None or not util.IsPreviewable(safeTypeID):
log.LogError('Type ID passed to Client.ShowPreview was invalid:',
typeID)
return
sm.GetService('preview').PreviewType(safeTypeID)
def _PrepareMainFlags(englishEntry, messageID):
if englishEntry is None:
log.LogError(
'Didnt find the English text row for English tag. messageID (%s)' %
messageID)
return {}
return {EXPORT_XML_DATAID: str(englishEntry.dataID)}
def GetReferees(self, data, *args):
refList = []
object = data.instanceData
referrers = gc.get_referrers(object)
myref = stackless.getcurrent().frame
known = [
gc.garbage,
stackless.getcurrent().frame, object, data, self.scroll
]
for ref in referrers:
if ref not in known:
try:
objectName = self.GetObjectName(ref)
listEntry = ScrollEntryNode(decoClass=SE_GenericCore,
id=id,
name=objectName,
label=objectName,
sublevel=1)
refList.append(listEntry)
except Exception as e:
log.LogError(
'Failed naming reference! Need to do something about this error'
)
return refList
def GetActiveStarColorMode(self):
"""
This function will call functions that match Get*Options to pull in each
sub folder of options
"""
starscolorby = settings.user.ui.Get('starscolorby', mapcommon.STARMODE_SECURITY)
if not self.starColorByID:
self.starColorByID = {}
groupList = ['Root'] + self.GetAllStarColorGroupLabels()
try:
groupList.remove('Sovereignty_Sovereignty')
except ValueError:
log.LogError('Error while removing a sov option from the prime list - a long load may be impending!')
for groupName in groupList:
func = getattr(self, 'Get%sOptions' % groupName, None)
if func is None:
continue
ops = func()
for label, id in ops:
self.starColorByID[id] = (groupName, label)
if starscolorby not in self.starColorByID:
if type(starscolorby) == types.TupleType and starscolorby[0] in (mapcommon.STARMODE_FACTION, mapcommon.STARMODE_MILITIA, mapcommon.STARMODE_FACTIONEMPIRE):
_starmode, factionID = starscolorby
options = {mapcommon.STARMODE_FACTION: ('Sovereignty_Sovereignty', localization.GetByLabel('UI/Map/MapPallet/cbModeFactions')),
mapcommon.STARMODE_FACTIONEMPIRE: ('Sovereignty_Sovereignty', localization.GetByLabel('UI/Map/MapPallet/cbStarsByEmpireFactions'))}.get(_starmode, (None, None))
colorBy, factionName = options
if factionID >= 0:
factionName = cfg.eveowners.Get(factionID).name
self.starColorByID[starscolorby] = (colorBy, factionName)
elif starscolorby == mapcommon.STARMODE_SOV_STANDINGS:
self.starColorByID[starscolorby] = ('Sovereignty_Sovereignty', localization.GetByLabel('UI/Map/MapPallet/cbStarsByStandings'))
return self.starColorByID.get(starscolorby, (None, None))
def DeleteMessageGroups(mappingRule, key, lookup, *args):
groupsToDelete = []
for mapping in _mappingRules[mappingRule]:
group = MessageGroup.Get(mapping.parentID)
if mapping.lookup:
if lookup is None:
raise Exception('lookup defined in rule but not passed in!')
for lookupItem in lookup.split('/'):
for groupItem in MessageGroup.GetMessageGroupsByParentID(
parentID=group.groupID):
if groupItem.groupName == lookupItem:
groupsToDelete.append(groupItem.groupID)
break
if mapping.pattern is not None:
groupID = _GetGroupID(group.groupID, key)
if groupID is not None:
groupsToDelete.append(groupID)
for groupID in groupsToDelete:
g = MessageGroup.Get(groupID)
if not g.Delete():
log.LogError(
'Localization update tool:: Error deleting group with id %d and name %s'
% (groupID, g.groupName))
def OnClick(self, *args):
sm.StartService('ui').StopBlink(self)
if self.destroyed:
ClearMenuLayer()
return
if self.killsub and isinstance(self.action[1], list):
uthread.new(self.action[1][0][1], self.action[1][0][2][0])
ClearMenuLayer()
return
if isinstance(self.action[1], basestring):
sm.StartService('gameui').Say(self.action[1])
else:
try:
actionMenuLabel = self.action[0]
labelPath = actionMenuLabel[0]
if len(self.action) > 2 and self.action[2]:
funcArgs = self.action[2]
if sm.GetService('menu').CaptionIsInMultiFunctions(
labelPath) and not isinstance(
funcArgs[0], types.MethodType):
funcArgs = (funcArgs, )
else:
funcArgs = ()
apply(self.action[1], funcArgs)
except Exception as e:
log.LogError(e, 'Failed executing action:', self.action)
log.LogException()
sys.exc_clear()
ClearMenuLayer()
def DDXTabOffices(self):
try:
log.LogInfo('>>>DDXTabOffices')
for each in self.rentableItems:
if each.typeID == const.typeOfficeFolder:
pass
else:
log.LogError('Unknown typeID on Corporation Folder %s (typeID) %s (CorpID)' % each.typeID, eve.session.corpid)
continue
publiclyAvailable = self.GetEntryDataByName('offices_type%s_number%s' % (each.typeID, each.number)).checked
if each.publiclyAvailable == publiclyAvailable:
continue
each.publiclyAvailable = publiclyAvailable
bFound = 0
for row in self.modifiedRentableItems:
if row.typeID == each.typeID and row.number == each.number:
bFound = 1
row.publiclyAvailable = publiclyAvailable
break
if not bFound:
self.modifiedRentableItems.append(each)
finally:
log.LogInfo('<<<DDXTabOffices')
def OnTabOffices(self):
scrolllist = []
scrollHeaders = [localization.GetByLabel('UI/Corporations/Common/Offices'),
localization.GetByLabel('UI/Station/OfficeNumber'),
localization.GetByLabel('UI/Station/StationManagment/OfficeRentedBy'),
localization.GetByLabel('UI/Station/StationManagment/RentStartDate'),
localization.GetByLabel('UI/Station/StationManagment/RentPeriod'),
localization.GetByLabel('UI/Station/StationManagment/RentPeriodCost'),
localization.GetByLabel('UI/Station/StationManagment/RentBalanceDue')]
for each in self.rentableItems:
if each.typeID == const.typeOfficeFolder:
pass
else:
log.LogError('Unknown typeID on Corporation Folder %s (typeID) %s (CorpID)' % each.typeID, eve.session.corpid)
continue
rname = ''
if each.rentedToID is not None:
rname = localization.GetByLabel('UI/Station/StationManagment/OfficesTableRentedBy', rentername=cfg.eveowners.Get(each.rentedToID).name)
dataLabel = '<t>'.join([localization.GetByLabel('UI/Station/StationManagment/OfficesTablePubliclyAvailable'),
util.FmtAmt(each.number),
rname,
util.FmtDate(each.startDate, 'ln') if each.startDate else u'',
util.FmtAmt(each.rentPeriodInDays) if each.rentPeriodInDays else u'',
util.FmtISK(each.periodCost) if each.periodCost else u'',
util.FmtDate(each.balanceDueDate, 'ln') if each.balanceDueDate else u''])
data = {'label': dataLabel,
'checked': each.publiclyAvailable,
'cfgname': 'offices',
'retval': 'type%s_number%s' % (each.typeID, each.number),
'OnChange': self.CheckBoxChange,
'name': 'offices_type%s_number%s' % (each.typeID, each.number)}
scrolllist.append(listentry.Get('Checkbox', data))
self.ddxFunction = self.DDXTabOffices
self.sr.scroll2.Load(fixedEntryHeight=24, contentList=scrolllist, headers=scrollHeaders)
def Close(self):
try:
self.ChangeSignalConnection(connect=False)
except Exception as e:
log.LogError('Failed at closing fitting left panel, e = ', e)
finally:
Container.Close(self)
def _GetFileContents(cls, projectID, getSubmittedOnly, bsdBranchID=None):
exportData = cls._GetLocalizationMessageDataForExport(
projectID, getSubmittedOnly, bsdBranchID=bsdBranchID)
folderPathToLabelsIndex = exportData[0]
languageCodesResultSet = exportData[2]
fontConfig = u''
for aLanguageRow in languageCodesResultSet:
languageID = aLanguageRow.languageID
if languageID not in cls.SCALEFORM_LANGUAGE_NAME_MAP:
log.LogError(
'Language', languageID,
'is not valid for Scaleform export. Please add the language to the SCALEFORM_LANGUAGE_NAME_MAP dictionary.'
)
continue
header, headerParams = cls.SCALEFORM_LANGUAGE_NAME_MAP[languageID]
fontConfig += header % headerParams
fontConfig += cls.FILE_NEXTLINE
fontConfig += cls.FILE_NEXTLINE
for folderPath, messageRows in folderPathToLabelsIndex.iteritems():
denormalizedFolderName = folderPath.replace('/', '_').strip()
for aMessage in messageRows:
textRow = aMessage.GetTextRow(languageID)
if textRow is not None and textRow.text is not None:
if denormalizedFolderName:
msgID = '_'.join((denormalizedFolderName,
aMessage.labelRow.label))
else:
msgID = aMessage.labelRow.label
trText = textRow.text
trText = trText.replace('"', "'")
fontConfig += u'tr "%s" = "%s"' % (msgID, trText)
fontConfig += cls.FILE_NEXTLINE
return fontConfig
def GetLastSemaphore(self):
try:
event, args, semaphore = self._queue[-1]
return semaphore
except:
log.LogError('Missing semaphore')
return None
def HideLoading(self, forceOff=0):
try:
if not self.loadingWheel.forcedOn or forceOff:
self.loadingWheel.Hide()
self.loadingWheel.forcedOn = 0
except:
log.LogError('Failed to hide the loading wheel')
def LoadMotd(self, hidden = False):
ip = self.serverIP
try:
extraParam = sm.StartService('patch').GetWebRequestParameters()
if boot.region == 'optic':
url = WEB_EVE + '/motd.html?server=%s&%s'
encoding = 'gbk'
else:
url = WEB_EVE + '/motd/%s?%s'
encoding = 'utf-8'
ret = corebrowserutil.GetStringFromURL(url % (ip, extraParam)).read()
except Exception as e:
log.LogError('Failed to fetch motd', e)
sys.exc_clear()
ret = ''
if self.motdParent and not self.motdParent.destroyed:
if ret and ret.startswith('MOTD '):
ret = ret[5:]
self.motdText = ret.decode(encoding, 'replace')
if hidden:
self.motdParent.state = uiconst.UI_HIDDEN
else:
self.motdParent.state = uiconst.UI_NORMAL
self.motdLabel.text = self.motdText
self.motdParent.height = max(32, self.motdLabel.textheight + 10)
else:
self.motdParent.state = uiconst.UI_HIDDEN
def GetBloodlinePos(self, bloodlineID):
blue.resMan.Wait()
camera = uicore.layer.charactercreation.camera
left = top = 0
if getattr(uicore.layer.charactercreation, 'bloodlineSelector',
None) is not None:
pos = uicore.layer.charactercreation.bloodlineSelector.GetProjectedPosition(
bloodlineID, None, camera)
self.isFemaleLeft = uicore.layer.charactercreation.bloodlineSelector.GetGenderOrder(
bloodlineID)
else:
log.LogError(
'Trying to place bloodline UI, but bloodlineSelector is None!')
pos = (0.0, 0.0)
if pos:
left = int(pos[0] / uicore.desktop.dpiScaling)
top = int(pos[1] / uicore.desktop.dpiScaling)
cont = self.sr.Get('cont_%d' % bloodlineID)
cont.left = left - cont.width / 2
cont.top = top - cont.height / 2 - 35
cont.state = uiconst.UI_PICKCHILDREN
if not self.isFemaleLeft:
cont = self.sr.Get('cont_%d' % bloodlineID)
genderBtnFemale = self.sr.Get('genderBtn_%d_%d' % (bloodlineID, 0))
genderBtnMale = self.sr.Get('genderBtn_%d_%d' % (bloodlineID, 1))
genderBtnMale.SetAlign(uiconst.BOTTOMLEFT)
genderBtnFemale.SetAlign(uiconst.BOTTOMRIGHT)
def _RequestTrust(self, inputUrl):
if not inputUrl.startswith('http://') and not inputUrl.startswith(
'https://'):
log.LogError(
'CCPEVE.RequestTrust - Input URL must start with either http:// or https:// -- received',
inputUrl)
return
scheme, netloc, path, query, fragment = urlparse.urlsplit(inputUrl)
if path is None or path == '':
path = '/'
trustUrl = '%s://%s%s' % (scheme, netloc, path)
if sm.GetService('sites').IsTrusted(trustUrl) or sm.GetService(
'sites').IsIgnored(trustUrl):
log.LogInfo(
'CCPEVE.RequestTrust - Received top-level URL is already trusted or ignored:',
trustUrl)
return
currentUrl = self.GetCurrentURL()
if sm.GetService('sites').IsIgnored(currentUrl):
log.LogInfo(
'CCPEVE.RequestTrust - Calling URL is ignored, discarding:',
currentUrl)
return
wnd = uicls.TrustedSitePromptWindow.GetIfOpen(
windowID='trustPromptWindow_%s' % netloc)
if wnd:
wnd.Maximize()
log.LogWarn(
'CCPEVE.RequestTrust - Trust prompt window was already open - skipping!'
)
return
wnd = uicls.TrustedSitePromptWindow.Open(
windowID='trustPromptWindow_%s' % netloc,
trustUrl=inputUrl,
inputUrl=currentUrl)
def GetBlueprintPrice(typeID):
try:
if boot.role == 'client':
blueprint = sm.GetService('blueprintSvc').GetBlueprintType(typeID)
else:
blueprint = sm.GetService('blueprintManager').GetBlueprintType(
typeID)
materials = blueprint.activities[industry.MANUFACTURING].materials
return sum([
GetBlueprintPrice(material.typeID) * material.quantity
for material in materials
])
except (KeyError, UserError):
pass
try:
if typeID is not None:
adjustedAveragePrice = inventorycommon.typeHelpers.GetAdjustedAveragePrice(
typeID)
if adjustedAveragePrice:
return adjustedAveragePrice
except KeyError:
pass
log.LogError(
'industryCommon.GetBlueprintPrice missing adjustedAveragePrice for type: ',
typeID)
return 0
def _SetStructureName(structureID, solarsystemID):
if not util.IsSolarSystem(solarsystemID):
log.LogError("Can't rename a structure that's not in space. What is",
structureID, 'doing inside', solarsystemID, 'anyways?')
return
currentName = cfg.evelocations.Get(structureID).locationName
namePrefix = '%s - ' % localization.CleanImportantMarkup(
cfg.evelocations.Get(solarsystemID).locationName)
if not currentName.startswith(namePrefix):
currentName = namePrefix + currentName
def _CheckLen(name, *args):
if len(name) - len(namePrefix) < structures.MIN_STRUCTURE_NAME_LEN:
raise UserError('CharNameTooShort')
newName = uiutil.NamePopup(
localization.GetByLabel('UI/Menusvc/SetName'),
localization.GetByLabel('UI/Menusvc/TypeInNewName'),
setvalue=currentName,
maxLength=32 + len(namePrefix),
fixedPrefix=namePrefix,
validator=_CheckLen)
if newName:
sm.RemoteSvc('structureDeployment').RenameStructure(
structureID, newName)
def InternalUpdateServerStatus(self, allowPatch, bootbuild, bootversion):
self.SetStatusText(localization.GetByLabel('UI/Login/CheckingStatus'))
self.serverStatusTextFunc = None
blue.pyos.synchro.Yield()
if self.isShowingUpdateDialog:
return
if not self.IsServerPortValid():
return
serverUserCount = serverversion = serverbuild = servercodename = None
isAutoPatch = self.GetIsAutoPatch(allowPatch)
try:
log.LogInfo('checking status of %s' % self.serverIP)
try:
if self.firstCheck:
forceQueueCheck = True
self.firstCheck = False
else:
forceQueueCheck = False
statusMessage, serverStatus = sm.GetService(
'machoNet').GetServerStatus(
'%s:%s' % (self.serverIP, self.serverPort),
forceQueueCheck=forceQueueCheck)
except UserError as e:
if e.msg == 'AlreadyConnecting':
sys.exc_clear()
return
raise
if not self.isopen:
return
self.serverStatus[self.serverIP] = (
serverStatus.get('cluster_usercount',
None), serverStatus.get('boot_version', None),
serverStatus.get('boot_build', None),
str(serverStatus.get('boot_codename', const.responseUnknown)),
serverStatus.get('update_info', const.responseUnknown))
serverUserCount, serverversion, serverbuild, servercodename, updateinfo = self.serverStatus[
self.serverIP]
if serverUserCount:
uthread.new(self.StartXFire,
str(fmtutil.FmtAmt(serverUserCount)))
actualStatusMsg = self.GetActualStatusMessage(
serverUserCount, serverbuild, serverversion, statusMessage)
if serverversion and serverbuild:
self.CompareVersionsAndAct(bootbuild, bootversion, isAutoPatch,
serverbuild, serverversion,
actualStatusMsg)
elif actualStatusMsg is not None and 'IncompatibleProtocol' in actualStatusMsg:
self.DisplayOutOfDateMessageAndQuitGame(
'Incompatable protocol')
else:
raise Exception('Invalid answer from server GetServerStatus')
except Exception as e:
log.LogError(e)
sys.exc_clear()
self.SetStatusText(
localization.GetByLabel('UI/Login/UnableToConnect',
IP=self.serverIP,
port=self.serverPort))
self.serverStatusTextFunc = None
def GetShipGroupSubContent(self, nodedata, *args):
scrolllist = []
fittingsByType = {}
shipTypes = []
for fitting in nodedata.fittings:
shipTypeID = fitting.shipTypeID
shipType = cfg.invtypes.GetIfExists(shipTypeID)
if not shipType:
log.LogError('Ship in stored fittings does not exist, shipID=%s, fittingID=%s' % (shipTypeID, fitting.fittingID))
continue
if shipTypeID not in fittingsByType:
fittingsByType[shipTypeID] = []
fittingsByType[shipTypeID].append(fitting)
if (shipType.name, shipTypeID) not in shipTypes:
shipTypes.append((shipType.name, shipTypeID))
shipTypes.sort()
for typeName, typeID in shipTypes:
data = util.KeyVal()
data.GetSubContent = self.GetFittingSubContent
data.label = typeName
data.groupItems = fittingsByType[typeID]
data.fittings = fittingsByType[typeID]
data.id = ('fittingMgmtScrollWndType', typeName)
data.sublevel = 1
data.showicon = 'hide'
data.state = 'locked'
scrolllist.append(listentry.Get('Group', data=data))
return scrolllist
def GetShipsAndGroups(self, filterTextLower, fittings):
fittingsByGroupID = defaultdict(list)
fittingsByGroupAndRaceIDs = defaultdict(lambda: defaultdict(set))
if not fittings:
shipGroups, shipsByGroupID, shipsByGroupAndRaceIDs = self.GetAllShipGroupsAndShipsByGroupID(
filterTextLower)
else:
shipGroups = set()
shipsByGroupID = defaultdict(set)
shipsByGroupAndRaceIDs = defaultdict(lambda: defaultdict(set))
for fittingID, fitting in fittings.iteritems():
shipTypeID = fitting.shipTypeID
if not evetypes.Exists(shipTypeID):
log.LogError(
'Ship in stored fittings does not exist, shipID=%s, fittingID=%s'
% (shipTypeID, fittingID))
continue
groupID = evetypes.GetGroupID(shipTypeID)
fittingsByGroupID[groupID].append(fitting)
groupName = evetypes.GetGroupName(shipTypeID)
shipGroups.add((groupName, groupID))
raceID = evetypes.GetRaceID(shipTypeID)
shipsByGroupAndRaceIDs[groupID][raceID].add(shipTypeID)
fittingsByGroupAndRaceIDs[groupID][raceID].add(fitting)
return (fittingsByGroupID, shipsByGroupID, shipGroups,
shipsByGroupAndRaceIDs, fittingsByGroupAndRaceIDs)
def GetShipGroupSubContent(self, nodedata, *args):
scrolllist = []
fittingsByType = defaultdict(list)
fittingNumByTypeID = nodedata.fittingNumByTypeID
for fitting in nodedata.fittings:
shipTypeID = fitting.shipTypeID
if not evetypes.Exists(shipTypeID):
log.LogError(
'Ship in stored fittings does not exist, shipID=%s, fittingID=%s'
% (shipTypeID, fitting.fittingID))
continue
fittingsByType[shipTypeID].append(fitting)
allShips = nodedata.allShips
for typeID in allShips:
typeName = evetypes.GetName(typeID)
numPersonal = fittingNumByTypeID[typeID][False]
numCorp = fittingNumByTypeID[typeID][True]
fittingsForType = fittingsByType.get(typeID, [])
entry = self.GetShipTypeGroup(typeID, typeName, fittingsForType,
numPersonal, numCorp)
scrolllist.append((typeName, entry))
scrolllist = SortListOfTuples(scrolllist)
return scrolllist