def read(self):
try:
message = self.socket.recv(4096)
except Exception as e:
Log.e(getExceptionInfo(e))
return Client.ReadError
if len(message) == 0:
return Client.NoMessage
self.buf += message
while len(self.buf) > 4:
length = int(self.buf[0:4])
if not len(self.buf) >= length + 4:
break
msg = self.buf[4:length + 4]
self.buf = self.buf[length + 4:]
message = Message()
if not message.loads(msg):
Log.w(u'Unknown Message')
else:
self.requests.put(message)
return Client.NewMessage
def handleSaveClicked(self):
readable = self.readableEdit.text()
username = self.nameEdit.text()
password = self.passwordEdit.text()
if len(username) > 0 and len(password) > 0:
resourceId = uuid.uuid4().hex
account = {
'id': resourceId,
'desc': readable,
'username': username,
'password': password
}
self.wantSaveAccount.emit(account)
clientId = application.getRandomClientId()
message = Message(cmd=Message.CMD_ADD_ACCOUNT)
message['account'] = account
if clientId:
EventManager.trigger(
Event('Client.replyReady.' + clientId, message))
application.addResource(resourceId, clientId)
toolBarId = application.lookUpToolBarIdByResourceId(resourceId)
if toolBarId:
EventManager.trigger(
Event('ToolBar.changeState.' + toolBarId, True))
else:
Log.e(u'未找到对应的服务器，增加失败')
else:
Log.w(u'用户名和密码均不为空时才能保存')
def load(self, name, vmId, port, password):
self.vmInfo = {'name': name, 'port': port, 'password': password, 'obj': self}
try:
self.mach = self.vbox.findMachine(name)
desc = self.mach.getGuestPropertyValue('vm_desc')
self.vmInfo['desc'] = str(desc) if desc else ''
type_ = self.mach.getGuestPropertyValue('vm_type')
if not type_ or int(type_) not in (VirtualMachine.Type_Stand, VirtualMachine.Type_Id_Extract):
self.vmInfo['status'] = VirtualMachine.Status_Invalid
self.vmInfo['type'] = -1
return self.vmInfo
self.vmInfo['type'] = int(type_)
if self.mach.state == self.mgr.constants.MachineState_Running:
self.vmInfo['status'] = VirtualMachine.Status_Running
return self.vmInfo
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.mach.lockMachine(self.session, self.mgr.constants.LockType_Write)
mutable = self.session.machine
mutable.setGuestPropertyValue('vm_vmId', vmId)
mutable.VRDEServer.setVRDEProperty('VNCPassword', str(password))
mutable.VRDEServer.setVRDEProperty('TCP/Ports', str(port))
mutable.VRDEServer.enabled = True
mutable.saveSettings()
self.session.unlockMachine()
except Exception, e:
Log.e(getExceptionInfo(e))
return
def handleAddGpsOk(self, request):
toolBarId = application.lookUpToolBarIdByResourceId(request['id'])
if toolBarId:
EventManager.trigger(
Event('ToolBar.changeState.' + toolBarId, False))
else:
Log.e(u'未找到需要改变状态的ToolBar')
def dumps(self):
if 'cmd' not in self.params:
Log.e('cmd不存在')
return None
message = json.dumps(self.params)
Log.i('生成Message: ' + message)
return bytes(message).encode('utf-8')
def queryVms(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.queryVms: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.queryVms: 该客户端在服务器中不存在')
return
vms = self.vm.getAllMachines()
vms_ = {}
for index, vmId in enumerate(vms):
vm = vms[vmId]
vms_[vm['name']] = {
'status': vm['status'],
'vmId': vmId,
'vmType': vm['type'],
'desc': vm['desc']
}
message = Message(cmd=Message.CMD_QUERY_VMS_OK)
message['vms'] = {
'name': '服务器',
'serverId': clientId,
'desc': '',
'vms': vms_
}
EventManager.trigger(Event('Socket.addReply.' + clientId, message))
def getParam(self, name):
param = None
try:
param = self.request[name]
except Exception as e:
Log.e(getExceptionInfo(e))
return param
def deleteSelectedItems(self):
selection = self.gpsTable.selectionModel()
indexes = selection.selectedRows()
#uuids: {clientId: [uuid,]}
uuids = {}
for index in indexes:
uuid_ = self.gpsModel.gpsItems[index.row()].id()
clientId = application.lookUpClientIdByResourceId(uuid_)
if clientId in uuids:
uuids[clientId].append(uuid_)
else:
uuids[clientId] = [uuid_]
if len(uuids) == 0:
return
for clientId in uuids:
message = Message(cmd=Message.CMD_DELETE_GPS)
message['ids'] = uuids[clientId]
EventManager.trigger(Event('Client.replyReady.' + clientId, message))
self.deleteGpsItems(uuids[clientId])
for uuid_ in uuids[clientId]:
toolBarId = application.lookUpToolBarIdByResourceId(uuid_)
if toolBarId:
EventManager.trigger(Event('ToolBar.changeState.' + toolBarId, True))
else:
Log.e(u'未找到对应的ToolBar')
def dumps(self):
if 'cmd' not in self.params:
Log.e('cmd不存在')
return None
message = json.dumps(self.params)
Log.i('生成Message: ' + message)
return bytes(message).encode('utf-8')
def dispatchRequest(self, request):
cmd = request.getCMD()
if not cmd:
Log.i('缺少cmd参数')
identifier = request.getParam('identifier')
EventManager.trigger(Event('Socket.addReply.' + identifier,
request))
def read(self):
try:
message = self.socket.recv(4096)
except Exception as e:
Log.e(getExceptionInfo(e))
return Client.ReadError
if len(message) == 0:
return Client.NoMessage
self.buf += message
while len(self.buf) > 4:
length = int(self.buf[0:4])
if not len(self.buf) >= length + 4:
break
msg = self.buf[4: length + 4]
self.buf = self.buf[length + 4:]
message = Message()
if not message.loads(msg):
Log.w(u'Unknown Message')
else:
self.requests.put(message)
return Client.NewMessage
def __getitem__(self, item):
param = None
try:
param = self.params[item]
except Exception as e:
Log.e(getExceptionInfo(e))
return param
def load(self, name, vmId, port, password):
self.vmInfo = {
'name': name,
'port': port,
'password': password,
'obj': self
}
try:
self.mach = self.vbox.findMachine(name)
desc = self.mach.getGuestPropertyValue('vm_desc')
self.vmInfo['desc'] = str(desc) if desc else ''
type_ = self.mach.getGuestPropertyValue('vm_type')
if not type_ or int(type_) not in (VirtualMachine.Type_Stand,
VirtualMachine.Type_Id_Extract):
self.vmInfo['status'] = VirtualMachine.Status_Invalid
self.vmInfo['type'] = -1
return self.vmInfo
self.vmInfo['type'] = int(type_)
if self.mach.state == self.mgr.constants.MachineState_Running:
self.vmInfo['status'] = VirtualMachine.Status_Running
return self.vmInfo
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.mach.lockMachine(self.session,
self.mgr.constants.LockType_Write)
mutable = self.session.machine
mutable.setGuestPropertyValue('vm_vmId', vmId)
mutable.VRDEServer.setVRDEProperty('VNCPassword', str(password))
mutable.VRDEServer.setVRDEProperty('TCP/Ports', str(port))
mutable.VRDEServer.enabled = True
mutable.saveSettings()
self.session.unlockMachine()
except Exception, e:
Log.e(getExceptionInfo(e))
return
def getParam(self, name):
param = None
try:
param = self.request[name]
except Exception as e:
Log.e(getExceptionInfo(e))
return param
def __getitem__(self, item):
param = None
try:
param = self.params[item]
except Exception as e:
Log.e(getExceptionInfo(e))
return param
def queryAccount(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.queryAccount: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.queryAccount: 该客户端在服务器中不存在')
return
EventManager.trigger(Event('DataCenter.loadAllAccount', clientId))
def updateGps(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.updateGps: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.updateGps: 该客户端在服务器中不存在')
return
EventManager.trigger(Event('DataCenter.updateGps', request['id'], request['desc'], clientId))
def queryAccount(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.queryAccount: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.queryAccount: 该客户端在服务器中不存在')
return
EventManager.trigger(Event('DataCenter.loadAllAccount', clientId))
def handleDeleteGpsOk(self, request):
ids = request['ids']
for id_ in ids:
toolBarId = application.lookUpToolBarIdByResourceId(id_)
if toolBarId:
EventManager.trigger(Event('ToolBar.changeState.' + toolBarId, False))
else:
Log.e(u'未找到需要改变状态的ToolBar')
application.delItemFromToolBar(id_)
def lastInsertRowId(self):
query = QSqlQuery(self.db)
if not query.exec_('SELECT last_insert_rowid()'):
Log.e('获取最后插入id失败')
return False
if not query.next():
Log.e('获取最后插入id失败')
return False
return query.value(0)
def handleDeleteGpsOk(self, request):
ids = request['ids']
for id_ in ids:
toolBarId = application.lookUpToolBarIdByResourceId(id_)
if toolBarId:
EventManager.trigger(
Event('ToolBar.changeState.' + toolBarId, False))
else:
Log.e(u'未找到需要改变状态的ToolBar')
application.delItemFromToolBar(id_)
def deleteGps(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.deleteGps: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.deleteGps: 该客户端在服务器中不存在')
return
EventManager.trigger(
Event('DataCenter.deleteGps', request['ids'], clientId))
def clearVmForClient(self, clientId):
if clientId in self.externalToVm:
for vm in self.externalToVm[clientId]:
success, vmInfo = self.vm.closeMachine(vm[0])
if not success:
Log.e('关闭虚拟机失败:' + vm[1]['name'])
continue
message = Message(cmd=Message.CMD_VM_UPDATED, vmId=vm[0], status=VirtualMachine.Status_Idle)
EventManager.trigger(Event('Message.broadcast', message, ()))
del self.externalToVm[clientId]
def reply(self):
reply = self.replies.get()
data = reply.dumps()
if data:
try:
self.socket.send(bytes(str(len(data)).zfill(4)) + data)
return self.WriteSuccess
except Exception as e:
Log.e("Can't send reply: " + getExceptionInfo(e))
return self.WriteError
def addRecord(self, table, **kwargs):
model = QSqlTableModel(self, self.db)
model.setTable(table)
record = model.record()
for field in kwargs:
record.setValue(field, kwargs[field])
if not model.insertRecord(-1, record):
Log.e('添加记录失败')
return False
else:
model.submitAll()
def addAccount(self, request):
clientId = request.getParam('clientId')
account = request['account']
if not clientId:
Log.e('ExternalDispatcher.addAccount: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.addAccount: 该客户端在服务器中不存在')
return
EventManager.trigger(
Event('DataCenter.addAccount', account['id'], account['desc'],
account['username'], account['password'], clientId))
def clearVmForClient(self, clientId):
if clientId in self.externalToVm:
for vm in self.externalToVm[clientId]:
success, vmInfo = self.vm.closeMachine(vm[0])
if not success:
Log.e('关闭虚拟机失败:' + vm[1]['name'])
continue
message = Message(cmd=Message.CMD_VM_UPDATED,
vmId=vm[0],
status=VirtualMachine.Status_Idle)
EventManager.trigger(Event('Message.broadcast', message, ()))
del self.externalToVm[clientId]
def addGps(self, request):
clientId = request.getParam('clientId')
gps = request['gps']
if not clientId:
Log.e('ExternalDispatcher.updateGps: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.updateGps: 该客户端在服务器中不存在')
return
EventManager.trigger(
Event('DataCenter.addGps', gps['id'], gps['desc'], gps['lng'],
gps['lat'], clientId))
def dispatchRequest(self, request):
cmd = request.getCMD()
if cmd in self.callbacks:
self.callbacks[cmd](request)
elif Message.CMD_BRIDGE_START <= cmd < Message.CMD_WEBCHAT_END:
try:
webchatId = request.getParam('webchatId')
EventManager.trigger(Event('Socket.addReply.' + webchatId, request))
except Exception as e:
Log.e(getExceptionInfo(e))
else:
Log.w('未实现的命令: ' + str(cmd))
def setGuestPropertyValue(self, key, value=None):
if not self.mach:
return
try:
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.mach.lockMachine(self.session, self.mgr.constants.LockType_Shared)
mutable = self.session.machine
mutable.setGuestPropertyValue(key, value)
mutable.saveSettings()
self.session.unlockMachine()
return True
except Exception, e:
Log.e(getExceptionInfo(e))
def createLogSidePanel(self):
position = Workspace.Bottom
logWindow = LogWindow()
logWindow.setStyleSheet('border-top: 1px solid #818A9A; background: #FFF')
Log.connect(logWindow)
toolbar = ToolBar('日志')
application.addToolBar(toolbar.id(), position, 0)
container = SideContainer()
container.setStyleSheet('SideContainer {border-top: 1px solid #818A9A;}')
container.setToolBar(toolbar)
container.setContentWidget(logWindow)
logButton = ChoiceButton(u'日志', QIcon('images/logo.png'))
self.addPanel(logButton, container, position, ChoiceBar.ChoiceBar_Bottom)
def addAccount(self, request):
clientId = request.getParam('clientId')
account = request['account']
if not clientId:
Log.e('ExternalDispatcher.addAccount: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.addAccount: 该客户端在服务器中不存在')
return
EventManager.trigger(
Event('DataCenter.addAccount', account['id'], account['desc'], account['username'],
account['password'], clientId)
)
def updateVm(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.updateVm: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.updateVm: 该客户端在服务器中不存在')
vmId = request['vmId']
self.vm.setGuestPropertyValue(vmId, 'desc', request['desc'])
message = Message(cmd=Message.CMD_UPDATE_VM_OK, vmId=vmId)
EventManager.trigger(Event('Socket.addReply.' + clientId, message))
message = Message(cmd=Message.CMD_VM_UPDATED, vmId=vmId, desc=request['desc'])
EventManager.trigger(Event('Message.broadcast', message, (clientId,)))
def dispatchRequest(self, request):
cmd = request.getCMD()
if cmd in self.callbacks:
self.callbacks[cmd](request)
elif Message.CMD_BRIDGE_START <= cmd < Message.CMD_WEBCHAT_END:
try:
webchatId = request.getParam('webchatId')
EventManager.trigger(
Event('Socket.addReply.' + webchatId, request))
except Exception as e:
Log.e(getExceptionInfo(e))
else:
Log.w('未实现的命令: ' + str(cmd))
def startVM(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.startVM: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.startVM: 该客户端在服务器中不存在')
return
vmId = request['vmId']
success, vmInfo = self.vm.startMachine(vmId)
if not success:
Log.e("启动虚拟机失败")
EventManager.trigger(Event('Socket.addReply.' + clientId,
Message(cmd=Message.CMD_VM_START_FAIL, vmId=vmId)))
return
else:
Log.i('成功启动虚拟机: ' + str(vmInfo['name']))
if clientId in self.externalToVm:
self.externalToVm[clientId].append((vmId, vmInfo))
else:
self.externalToVm[clientId] = [(vmId, vmInfo)]
EventManager.trigger(Event('Socket.addReply.' + clientId,
Message(cmd=Message.CMD_VM_START_OK, vmId=vmId, port=vmInfo['port'],
password=vmInfo['password'])))
message = Message(cmd=Message.CMD_VM_UPDATED, vmId=vmId, status=VirtualMachine.Status_Running)
EventManager.trigger(Event('Message.broadcast', message, ()))
def setGuestPropertyValue(self, key, value=None):
if not self.mach:
return
try:
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.mach.lockMachine(self.session,
self.mgr.constants.LockType_Shared)
mutable = self.session.machine
mutable.setGuestPropertyValue(key, value)
mutable.saveSettings()
self.session.unlockMachine()
return True
except Exception, e:
Log.e(getExceptionInfo(e))
def closeVM(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.closeVM: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.closeVM: 该客户端在服务器中不存在')
return
vmId = request.getParam('vmId')
if not vmId:
Log.e('ExternalDispatcher.closeVM: 缺少虚拟机Id参数')
return
for vm in self.externalToVm[clientId]:
if vm[0] == vmId:
success, vmInfo = self.vm.closeMachine(vmId)
if not success:
break
self.externalToVm[clientId].remove(vm)
message = Message(cmd=Message.CMD_VM_UPDATED,
vmId=vmId,
status=VirtualMachine.Status_Idle)
EventManager.trigger(Event('Message.broadcast', message, ()))
return True
Log.e("关闭虚拟机失败")
def startVM(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.startVM: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.startVM: 该客户端在服务器中不存在')
return
vmId = request['vmId']
success, vmInfo = self.vm.startMachine(vmId)
if not success:
Log.e("启动虚拟机失败")
EventManager.trigger(
Event('Socket.addReply.' + clientId,
Message(cmd=Message.CMD_VM_START_FAIL, vmId=vmId)))
return
else:
Log.i('成功启动虚拟机: ' + str(vmInfo['name']))
if clientId in self.externalToVm:
self.externalToVm[clientId].append((vmId, vmInfo))
else:
self.externalToVm[clientId] = [(vmId, vmInfo)]
EventManager.trigger(
Event(
'Socket.addReply.' + clientId,
Message(cmd=Message.CMD_VM_START_OK,
vmId=vmId,
port=vmInfo['port'],
password=vmInfo['password'])))
message = Message(cmd=Message.CMD_VM_UPDATED,
vmId=vmId,
status=VirtualMachine.Status_Running)
EventManager.trigger(Event('Message.broadcast', message, ()))
def createConnection(self):
self.db = QSqlDatabase('QSQLITE')
self.db.setHostName('localhost')
homeDir = QDir().home()
if not homeDir.exists('.ivy-common/'):
homeDir.mkdir('.ivy-common/')
self.db.setDatabaseName(QDir().homePath() + '/.ivy-common/' + self.name)
self.db.setUserName('arch')
self.db.setPassword('arch')
if not self.db.open():
Log.e('数据库打开失败，请重启程序')
return False
return True
def start(self):
if self.mach is None:
print u'虚拟机分配失败，无法启动'
elif self.mach.state == self.mgr.constants.MachineState_Running:
print u'虚拟机已经在运行中，不能重复启动'
else:
try:
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.progress = self.mach.launchVMProcess(self.session, "headless", "")
self.progress.waitForCompletion(-1)
self.console = self.session.console
return True
except Exception, e:
Log.e(getExceptionInfo(e))
def dispatchRequest(self, client):
Log.i('Default dispatcher: ' + str(client))
Log.w('You need to setDispatcher for the Server')
request = client.getRequest()
cmd = request.getCMD()
if cmd == Message.CMD_CLIENT_VALIDATED:
client.setClientId(request['clientId'])
message = Message(cmd=Message.CMD_QUERY_GPS, id=1)
EventManager.trigger(Event('Client.replyReady.' + client.clientId, message))
message = Message(cmd=Message.CMD_QUERY_GPS, id=2)
EventManager.trigger(Event('Client.replyReady.' + client.clientId, message))
message = Message(cmd=Message.CMD_QUERY_GPS, id=3)
EventManager.trigger(Event('Client.replyReady.' + client.clientId, message))
message = Message(cmd=Message.CMD_QUERY_GPS, id=4)
EventManager.trigger(Event('Client.replyReady.' + client.clientId, message))
def updateVm(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.updateVm: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.updateVm: 该客户端在服务器中不存在')
vmId = request['vmId']
self.vm.setGuestPropertyValue(vmId, 'desc', request['desc'])
message = Message(cmd=Message.CMD_UPDATE_VM_OK, vmId=vmId)
EventManager.trigger(Event('Socket.addReply.' + clientId, message))
message = Message(cmd=Message.CMD_VM_UPDATED,
vmId=vmId,
desc=request['desc'])
EventManager.trigger(Event('Message.broadcast', message, (clientId, )))
def start(self):
if self.mach is None:
print u'虚拟机分配失败，无法启动'
elif self.mach.state == self.mgr.constants.MachineState_Running:
print u'虚拟机已经在运行中，不能重复启动'
else:
try:
self.session = self.mgr.mgr.getSessionObject(self.vbox)
self.progress = self.mach.launchVMProcess(
self.session, "headless", "")
self.progress.waitForCompletion(-1)
self.console = self.session.console
return True
except Exception, e:
Log.e(getExceptionInfo(e))
def createLogSidePanel(self):
position = Workspace.Bottom
logWindow = LogWindow()
logWindow.setStyleSheet(
'border-top: 1px solid #818A9A; background: #FFF')
Log.connect(logWindow)
toolbar = ToolBar('日志')
application.addToolBar(toolbar.id(), position, 0)
container = SideContainer()
container.setStyleSheet(
'SideContainer {border-top: 1px solid #818A9A;}')
container.setToolBar(toolbar)
container.setContentWidget(logWindow)
logButton = ChoiceButton(u'日志', QIcon('images/logo.png'))
self.addPanel(logButton, container, position,
ChoiceBar.ChoiceBar_Bottom)
def queryVms(self, request):
clientId = request.getParam('clientId')
if not clientId:
Log.e('ExternalDispatcher.queryVms: 权限不足')
return
if clientId not in self.server.clients:
Log.e('ExternalDispatcher.queryVms: 该客户端在服务器中不存在')
return
vms = self.vm.getAllMachines()
vms_ = {}
for index, vmId in enumerate(vms):
vm = vms[vmId]
vms_[vm['name']] = {'status': vm['status'], 'vmId': vmId, 'vmType': vm['type'], 'desc': vm['desc']}
message = Message(cmd=Message.CMD_QUERY_VMS_OK)
message['vms'] = {'name': '服务器', 'serverId': clientId, 'desc': '', 'vms': vms_}
EventManager.trigger(Event('Socket.addReply.' + clientId, message))
def dispatchRequest(self, client):
request = client.getRequest()
cmd = request.getCMD()
if cmd == Message.CMD_CLIENT_VALIDATED:
client.setClientId(request['clientId'])
if cmd in self.callbacks:
request.setParam(clientId=client.clientId)
funcs = self.callbacks[cmd]
if isinstance(funcs, list):
for index, func in enumerate(funcs):
if index == len(funcs) - 1:
return func(request)
else:
func(request)
else:
return self.callbacks[cmd](request)
else:
Log.w('未实现的命令: ' + str(cmd))
def dispatchRequest(self, client):
request = client.getRequest()
cmd = request.getCMD()
if cmd == Message.CMD_CLIENT_VALIDATED:
client.setClientId(request['clientId'])
if cmd in self.callbacks:
request.setParam(clientId=client.clientId)
funcs = self.callbacks[cmd]
if isinstance(funcs, list):
for index, func in enumerate(funcs):
if index == len(funcs) - 1:
return func(request)
else:
func(request)
else:
return self.callbacks[cmd](request)
else:
Log.w('未实现的命令: ' + str(cmd))
def editLocation(self, index, unused, roles):
"""同步修改到服务器，对于GPS坐标来说，客户端只能更改坐标备注"""
if Qt.EditRole not in roles:
self.gpsTable.update()
return
item = self.gpsModel.itemForIndex(index)
resourceId = item.id()
clientId = application.lookUpClientIdByResourceId(resourceId)
if clientId:
message = Message(cmd=Message.CMD_UPDATE_GPS)
message['id'] = resourceId
message['desc'] = item.description()
EventManager.trigger(Event('Client.replyReady.' + clientId, message))
toolBarId = application.lookUpToolBarIdByResourceId(resourceId)
if toolBarId:
print 'ToolBar.changeState.' + toolBarId
EventManager.trigger(Event('ToolBar.changeState.' + toolBarId, True))
else:
Log.e(u'未找到对应的服务器，修改失败')
def data(self, index, role=None):
if not index.isValid() or index.column() < 0 or index.column() > self.columnCount():
return QVariant()
item = self.gpsItems[index.row()]
if role == Qt.DisplayRole or role == Qt.EditRole:
column = index.column()
if column == GpsModel.Description:
return item.description()
elif column == GpsModel.Lng:
return str(item.lng())
elif column == GpsModel.Lat:
return str(item.lat())
else:
Log.e('Unknown column index')
if role == Qt.TextAlignmentRole:
return Qt.AlignLeft | Qt.AlignVCenter
return QVariant()
def data(self, index, role=None):
if not index.isValid() or index.column() < 0 or index.column() > self.columnCount():
return QVariant()
item = self.items[index.row()]
if role == Qt.DisplayRole or role == Qt.EditRole:
column = index.column()
if column == AccountModel.Description:
return item.description()
elif column == AccountModel.Username:
return str(item.username())
elif column == AccountModel.Password:
return str(item.password())
else:
Log.e('Unknown column index')
if role == Qt.TextAlignmentRole:
return Qt.AlignLeft | Qt.AlignVCenter
return QVariant()
def data(self, index, role=None):
if not index.isValid(
) or index.column() < 0 or index.column() > self.columnCount():
return QVariant()
item = self.items[index.row()]
if role == Qt.DisplayRole or role == Qt.EditRole:
column = index.column()
if column == AccountModel.Description:
return item.description()
elif column == AccountModel.Username:
return str(item.username())
elif column == AccountModel.Password:
return str(item.password())
else:
Log.e('Unknown column index')
if role == Qt.TextAlignmentRole:
return Qt.AlignLeft | Qt.AlignVCenter
return QVariant()
def data(self, index, role=None):
if not self.rootItem or not index.isValid() or index.column() < 0 or index.column() > VMModel.ColumnCount:
return QVariant()
item = self.itemForIndex(index)
if role == Qt.DisplayRole or role == Qt.EditRole:
column = index.column()
if column == VMModel.Name:
return item.name()
elif column == VMModel.Type:
return ('站街/聊天', '提取id')[item.type()] if item.type() != -1 else ''
elif column == VMModel.Description:
return item.description()
else:
Log.e('Unknown column index')
if role == Qt.TextAlignmentRole:
if index.column() == VMModel.Name:
return Qt.AlignLeft | Qt.AlignVCenter
else:
return Qt.AlignCenter
def dumps(self):
reply = '{'
if 'cmd' not in self.params:
Log.e('cmd不存在')
return None
else:
for count, name in enumerate(self.params):
if count > 0:
reply += ', '
reply += '"{name}": '.format(name=name)
value = self.params[name]
if isinstance(value, str) or isinstance(value, unicode):
reply += '"{value}"'.format(value=value)
else:
reply += str(value)
reply.rstrip(' ')
reply += '}'
Log.i('生成Reply: ' + reply)
self.reply = bytes(reply).encode('utf-8')
return self.reply
def editAccount(self, index, unused, roles):
"""同步修改到服务器"""
if Qt.EditRole not in roles:
self.table.update()
return
item = self.model.itemForIndex(index)
resourceId = item.id()
clientId = application.lookUpClientIdByResourceId(resourceId)
if clientId:
message = Message(cmd=Message.CMD_UPDATE_ACCOUNT)
message['id'] = resourceId
message['desc'] = item.description()
message['username'] = item.username()
message['password'] = item.password()
EventManager.trigger(Event('Client.replyReady.' + clientId, message))
toolBarId = application.lookUpToolBarIdByResourceId(resourceId)
if toolBarId:
print 'ToolBar.changeState.' + toolBarId
EventManager.trigger(Event('ToolBar.changeState.' + toolBarId, True))
else:
Log.e(u'未找到对应的服务器，修改失败')
