def _onResponseFailure(self, ids, args):
     if super(AdminChatCommandHandler, self)._onResponseFailure(ids, args):
         error = errors.createAdminCommandError(args)
         if error:
             g_messengerEvents.onErrorReceived(error)
         else:
             LOG_WARNING('Error is not resolved on the client', ids, args)

 def error(self, pyGlooxTag):
     error = self._getError(pyGlooxTag)
     if error:
         g_messengerEvents.onErrorReceived(error)
     else:
         g_logOutput.error(_LOG_AREA.PY_WRAPPER, 'Error is not resolved on the client', self.__class__.__name__, pyGlooxTag.getXml())
     self._result = TASK_RESULT.CLEAR

 def _onResponseFailure(self, ids, args):
     if super(VOIPChatProvider, self)._onResponseFailure(ids, args):
         error = errors.createVOIPError(args)
         if error:
             g_messengerEvents.onErrorReceived(error)
         else:
             LOG_WARNING('Error is not resolved on the client', ids, args)

 def createPrivateChannel(self, dbID, name):
     if GUI_SETTINGS.useXmppToCreatePrivate:
         result, error = self.__xmppProto.messages.startChatSession(dbID, name)
         if not result:
             g_messengerEvents.onErrorReceived(error)
     else:
         self.__bwProto.users.createPrivateChannel(dbID, name)
     return True

 def _setIQError(self, tag):
     if self._step == ENTRY_STEP.SET_DATA_FORM:
         self._sendPresence(chat_ext.MUCLeaveQuery(self._getUserJID()))
     error = errors.createServerUserRoomCreationIQError(tag, self._room.getName())
     if error is not None:
         g_messengerEvents.onErrorReceived(error)
     self._remove()
     return

 def sendChatMessage(self, jid, body):
     if self.__cooldown.isInProcess(CLIENT_ACTION_ID.SEND_MESSAGE):
         g_messengerEvents.onErrorReceived(ChatCoolDownError(CLIENT_ACTION_ID.SEND_MESSAGE, self.__limits.getBroadcastCoolDown()))
         return
     body = self.__msgFilters.chainOut(body, self.__limits)
     if not body:
         return
     self.__chatSessions.sendMessage(ContactBareJID(jid), body, self.__msgFilters)
     self.__cooldown.process(CLIENT_ACTION_ID.SEND_MESSAGE)

 def sendPassword(self, value):
     validator = self.proto.messages.getUserRoomValidator()
     password, error = validator.validateUserRoomPwd(value)
     if error is not None:
         g_messengerEvents.onErrorReceived(error)
     else:
         self.proto.messages.joinToUserRoom(self._channel.getID(), password=password)
         self.destroy()
     return

 def parseLine(self, text, clientID = 0):
     cmd, result = None, admin_chat_cmd.parseCommandLine(text)
     if not result:
         return (False, None)
     if result.hasError():
         g_messengerEvents.onErrorReceived(result.getError())
     else:
         decorator = admin_chat_cmd.makeDecorator(result, clientID)
         if self.send(decorator):
             cmd = decorator
     return (True, cmd)

 def _onResponseFailure(self, ids, args):
     actionID = super(VOIPChatProvider, self)._onResponseFailure(ids, args)
     if actionID is None:
         return
     error, logOnly = errors.createVOIPError(args, actionID)
     if error:
         if logOnly:
             LOG_NOTE(error)
         else:
             g_messengerEvents.onErrorReceived(error)
     else:
         LOG_WARNING('Error is not resolved on the client to display in GUI', actionID, ids, args)

 def sendMessage(self, jid, body, filters):
     channel = self.channelsStorage.getChannel(entities.XMPPChatChannelEntity(jid))
     if channel:
         if self.playerCtx.isChatBan():
             error = createChatBanError(self.playerCtx.getBanInfo())
             if error:
                 g_messengerEvents.onErrorReceived(error)
                 return
         dbID = getPlayerDatabaseID()
         name = getPlayerName()
         g_messengerEvents.channels.onMessageReceived(XMPPMessageData(dbID, name, filters.chainIn(dbID, body), time.time()), channel)
         self.client().sendMessage(ChatMessageHolder(jid, msgBody=body))

 def _setPresenceError(self, tag):
     error = errors.createServerActionPresenceError(self._getActionID(), tag)
     if error is not None:
         if error.getErrorType() == ERROR_TYPE.AUTH and error.getCondition() == 'not-authorized' and self._step != ENTRY_STEP.PASSWORD_REQUIRED:
             self._step = ENTRY_STEP.PASSWORD_REQUIRED
             g_messengerEvents.channels.onConnectingToSecureChannel(self._room)
         else:
             g_messengerEvents.onErrorReceived(error)
             self._remove()
     else:
         self._remove()
     return

 def sendMessage(self, jid, body, filters):
     _, exists = self._searchChannel(jid)
     if exists is None:
         return
     elif self.playerCtx.isBanned(components=exists.getBanComponent()):
         error = createChatBanError(self.playerCtx.getBanInfo())
         if error:
             g_messengerEvents.onErrorReceived(error)
         return
     else:
         self._repeatMessage(exists, body, filters)
         self.client().sendMessage(chat_ext.ChatMessageHolder(exists.getMessageType(), jid, msgBody=body))
         return

 def doAction(self, actionID, args = None, response = False, skipCoolDown = False):
     success, reqID = False, 0
     if self.__coolDown.isInProcess(actionID):
         if not skipCoolDown:
             g_messengerEvents.onErrorReceived(createCoolDownError(actionID))
     else:
         if response:
             reqID = self.__idGen.next()
         if self.__isEnabled:
             success = self.__sendAction(actionID, reqID, args)
         else:
             success = self.__addActionToQueue(actionID, reqID, args)
     return (success, reqID)

 def _join(self, info):
     if info is not None:
         statuses = info.statuses
     else:
         statuses = ()
     if MUC_STATUS.SELF_PRESENCE in statuses and MUC_STATUS.CREATE_ROOM in statuses:
         self._step = ENTRY_STEP.SET_DATA_FORM
         self._sendIQ(chat_ext.UserRoomConfigurationFormSet(self._room.getID(), self._room.getName(), self._room.getPassword()))
     else:
         g_messengerEvents.onErrorReceived(ClientActionError(CLIENT_ACTION_ID.CREATE_USER_ROOM, CLIENT_ERROR_ID.GENERIC))
         self._result = ACTION_RESULT.DO_NOTHING
         self._sendPresence(chat_ext.MUCLeaveQuery(self._getUserJID()))
     return

    def handleIQ(self, iqID, iqType, tag):
        if iqID == self.__iqID:
            if iqType == IQ_TYPE.RESULT:
                self.__state = _HISTORY_RQ_STATE.RESULT
            elif iqType == IQ_TYPE.ERROR:
                self.__state = _HISTORY_RQ_STATE.UNAVAILABLE
                error = errors.createServerActionIQError(CLIENT_ACTION_ID.RQ_HISTORY, tag)
                if error:
                    g_messengerEvents.onErrorReceived(error)
                while self.__pool:
                    self.__setChannelHistory(self.__pool.pop(0))

            result = True
        else:
            result = False
        return result

 def createChannel(self, name, usePassword, password, retype):
     validator = self.proto.messages.getUserRoomValidator()
     name, error = validator.validateUserRoomName(name)
     if error is not None:
         g_messengerEvents.onErrorReceived(error)
         return
     else:
         if usePassword:
             pwd, error = validator.validateUserRoomPwdPair(password, retype)
             if error is not None:
                 g_messengerEvents.onErrorReceived(error)
                 return
         result = self.proto.messages.createUserRoom(name, password)
         if result:
             self.destroy()
         return

 def sendChatMessage(self, jid, body):
     if self.__cooldown.isInProcess(CLIENT_ACTION_ID.SEND_MESSAGE):
         g_messengerEvents.onErrorReceived(ChatCoolDownError(CLIENT_ACTION_ID.SEND_MESSAGE, MESSAGE_LIMIT.COOLDOWN))
         return
     self.__chatSessions.sendMessage(ContactBareJID(jid), body)
     self.__cooldown.process(CLIENT_ACTION_ID.SEND_MESSAGE)

 def addFriend(self, dbID, name, group = None):
     result, error = self.__xmppProto.contacts.addFriend(dbID, name, group)
     if not result:
         g_messengerEvents.onErrorReceived(error)
     return result

 def addIgnored(self, dbID, name):
     result, error = self.__xmppProto.contacts.addIgnored(dbID, name)
     if not result:
         g_messengerEvents.onErrorReceived(error)
     return result

 def removeNote(self, dbID):
     result, error = self.__xmppProto.contacts.removeNote(dbID)
     if not result:
         g_messengerEvents.onErrorReceived(error)
     return result