requestconfig.cpp

sip 开源代码 源于novell sip 开源代码 源于novell

/*
 *  Copyright (C) 2005 Savoir-Faire Linux inc.
 *  Author: Yan Morin <[e-mail]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "global.h"
#include "requestconfig.h"
#include "guiserver.h"

ResponseMessage
RequestGetEvents::execute()
{
  GUIServer::instance().getEvents(_sequenceId);
  return message("000", _("OK"));
}

ResponseMessage
RequestZeroconf::execute()
{
  if (GUIServer::instance().getZeroconf(_sequenceId)) {
    return message("200", _("OK"));
  } else {
    return message("501",_("Zeroconf not enabled or activated"));
  }
}

ResponseMessage
RequestZeroconfEvent::execute()
{
  if (GUIServer::instance().attachZeroconfEvents(_sequenceId, *this)) {
    return message("000", _("Zeroconf Events are running"));
  } else {
    return message("501",_("Zeroconf not enabled or activated"));
  }
}

RequestZeroconfEvent::~RequestZeroconfEvent() 
{
  GUIServer::instance().detachZeroconfEvents(*this);
}

void
RequestZeroconfEvent::update()
{
  TokenList tk; tk.push_back("New Zeroconf events - Not Implemented");
  GUIServer::instance().sendMessage("100", _sequenceId, tk);
}

ResponseMessage
RequestCallStatus::execute()
{
  //GUIServer::instance().sendGetEventsEnd();
  TokenList tk;
  tk.push_back(_("OK"));
  std::string code = "206";
  GUIServer::instance().getCallStatus(_sequenceId);

  std::string callid;
  if (GUIServer::instance().getCurrentCallId(callid)) {
    tk.push_front(callid);
  } else {
    code = "205";
  }
  return message(code, tk);
}

ResponseMessage
RequestAccountList::execute()
{
  std::string code;
  std::string response;
  if ( GUIServer::instance().getAccountList(_sequenceId) ) {
    code = "200";
    response = "OK";
  } else {
    code = "400";
    response = "No active account";
  }
  return message(code, _(response));
}

ResponseMessage
RequestConfigGetAll::execute()
{
  if (GUIServer::instance().getConfigAll(_sequenceId)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Server Error"));
  }
}

RequestConfigGet::RequestConfigGet(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  bool argsAreValid = false;
  if (iter != _argList.end()) {
    _section = *iter;
    _argList.pop_front();
    iter = _argList.begin();
    if (iter != _argList.end()) {
      _name = *iter;
      _argList.pop_front();
      argsAreValid = true;
    }
  }
  if (!argsAreValid) {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestConfigGet::execute()
{
  TokenList arg;
  if (GUIServer::instance().getConfig(_section, _name, arg)) {
    return message("200", arg);
  } else {
    //  402 seq10001 Variable unknown
    return message("402",_("Variable unknown"));
  }
}

RequestConfigSet::RequestConfigSet(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();

  // get three strings arguments
  bool argsAreValid = false;
  if (iter != _argList.end()) {
    _section = *iter;
    _argList.pop_front();
    iter = _argList.begin();
    if (iter != _argList.end()) {
      _name = *iter;
      _argList.pop_front();
      iter = _argList.begin();
      if (iter != _argList.end()) {
        _value = *iter;
        _argList.pop_front();
        argsAreValid = true;
      } else {
        _value = "";
        argsAreValid = true;
      }
    }
  }
  if (!argsAreValid) {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestConfigSet::execute()
{
  if (GUIServer::instance().setConfig(_section, _name, _value)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Server Error"));
  }
}

ResponseMessage
RequestConfigSave::execute()
{
  if (GUIServer::instance().saveConfig()) {
    return message("200", _("Config saved"));
  } else {
    return message("400",_("Error Unable to save the configuration"));
  }
}

RequestList::RequestList(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  if (iter != _argList.end()) {
    _name = *iter;
    _argList.pop_front();
  } else {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestList::execute()
{
  if (GUIServer::instance().getConfigList(_sequenceId, _name)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Server Error"));
  }
}

RequestVolumeSpkr::RequestVolumeSpkr(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  bool error = true;
  if (iter != _argList.end()) {
    _percent = atoi(iter->c_str());
    if (_percent >= 0 && _percent <= 100) {
      _argList.pop_front();
      error = false;
    }
  }
  if (error) {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestVolumeSpkr::execute()
{
  if (GUIServer::instance().setSpkrVolume(_percent)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Server Error"));
  }
}

RequestVolumeMic::RequestVolumeMic(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  bool error = true;
  if (iter != _argList.end()) {
    _percent = atoi(iter->c_str());
    if (_percent >= 0 && _percent <= 100) {
      _argList.pop_front();
      error = false;
    }
  }
  if (error) {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestVolumeMic::execute()
{
  if (GUIServer::instance().setMicVolume(_percent)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Server Error"));
  }
}

RequestRegister::RequestRegister(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  if (iter != _argList.end()) {
    _accountId = *iter;
    _argList.pop_front();
  } else {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestRegister::execute()
{
  if (GUIServer::instance().registerVoIPLink(_accountId)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Registration sending failed"));
  }
}

RequestUnregister::RequestUnregister(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  if (iter != _argList.end()) {
    _accountId = *iter;
    _argList.pop_front();
  } else {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestUnregister::execute()
{
  if (GUIServer::instance().unregisterVoIPLink(_accountId)) {
    return message("200", _("OK"));
  } else {
    return message("500",_("Unregistration sending failed"));
  }
}

RequestSwitch::RequestSwitch(const std::string &sequenceId, const TokenList& argList) : RequestGlobal(sequenceId,argList)
{
  TokenList::iterator iter = _argList.begin();
  if (iter != _argList.end()) {
    _switchName = *iter;
  } else {
    throw RequestConstructorException();
  }
}

ResponseMessage
RequestSwitch::execute()
{
  std::string switchMessage;
  if (GUIServer::instance().setSwitch(_switchName, switchMessage)) {
    return message("200", switchMessage);
  } else {
    return message("500", switchMessage);
  }
}