ActionConfig.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_WS_ACTION_CONFIG_H
#define __SSRC_WSPR_WS_ACTION_CONFIG_H

#include <ssrc/wispers/utility/Properties.h>
#include <ssrc/wispers/utility/NumberVisitor.h>
#include <ssrc/wispers/ws/types.h>

#include <boost/scoped_ptr.hpp>

__BEGIN_NS_SSRC_WSPR_WS

using std::string;
using NS_SSRC_WSPR_UTILITY::Properties;

struct ActionConfig {
  // TODO: consider changing these to a bitmap and use bit masks to access.
  bool one_way;
  bool requires_session;
  bool verify_session;
  bool updates_access_time;
  bool clears_session;
  // A value of 0 means doesn't create session, 1 means session expires
  // when user agent terminates, > 1 indicates lifetime in number of seconds.
  unsigned int creates_session;
  bool cache_result_template;
  bool permits_get;
  bool result_is_event;
  string action;
  string target;
  string call;
  string redirect;
  string failure_redirect;
  string result_template;
  string failure_template;
  // This is not currently used by Relay.
  // It is used by WebServiceRunner (and optionally WebService) to
  // perform parameter validation.  In the future, it may be used
  // by Relay for the same purpose.  If we use it for the relay,
  // we have to catch any exceptions thrown by bad parameter
  // validation patterns.  This is not a problem for WebServiceRunner
  // or WebService which load all action configs at startup.
  boost::scoped_ptr<parameter_sequence> parameters;

  void init(const string & action_name, const Properties & action_map) {
    action              = action_name;
    one_way             = action_map.get<bool>(false, "one_way");
    requires_session    = action_map.get<bool>(true, "requires_session");
    verify_session = action_map.get<bool>(requires_session, "verify_session");
    updates_access_time = action_map.get<bool>(true, "updates_access_time");
    clears_session      = action_map.get<bool>(false, "clears_session");
    creates_session     = action_map.get<unsigned int>(0, "creates_session");
    permits_get         = action_map.get<bool>(false, "permits_get");
    result_is_event     = action_map.get<bool>(false, "result_is_event");
    target              = action_map.get<string>("", "target");
    call                = action_map.get<string>("", "call");
    redirect            = action_map.get<string>("", "redirect");
    failure_redirect    = action_map.get<string>("", "redirect_on_failure");
    result_template     = action_map.get<string>("", "template");
    cache_result_template = action_map.get<bool>(false, "cache_template");
    failure_template    = action_map.get<string>("", "template_on_failure");

    if(result_template.empty()) {
      result_template = call;
      result_template.append(".result");
    }

    const Properties *p = action_map.find("parameters");

    if(p != 0) {
      SSRC_UNIQUE_PTR<CallParameter> param;
      Properties::child_container_const_iterator && it = p->child_begin();
      Properties::child_container_const_iterator && end = p->child_end();

      parameters.reset(new parameter_sequence);

      while(it != end) {
        const Properties* node  = it->second;
        const string & name = it->first;
        const unsigned int min_size =
          utility::get_number<unsigned int>(*node, 1, "min_size");
        const unsigned int max_size =
          utility::get_number<unsigned int>(*node, 128, "max_size");
        const bool multi_value = node->get<bool>(false, "multi_value");
        const bool optional = node->get<bool>(false, "optional");
        const string & pattern = node->get<string>("", "matches");

        if(pattern.empty()) {
          param.reset(new CallParameter(name, min_size, max_size, multi_value,
                                        optional));
        } else {
          param.reset(new PatternParameter(name, pattern,
                                           min_size, max_size, multi_value,
                                           optional));
        }

        parameters->push_back(param.release());

        ++it;
      }
    }
  }

  ActionConfig() { }

  //TODO: Reconcile these two constructors
  ActionConfig(const string & action_name, const Properties & action_node) {
    init(action_name, action_node);
  }

  bool invalid() const {
    return (target.empty() || call.empty());
  }
};


template<typename container_type>
void get_actions(container_type & result,
                 const Properties & action_map)
{
  const Properties *p = action_map.find("Action");

  if(p != 0) {
    Properties::child_container_const_iterator && it = p->child_begin();
    Properties::child_container_const_iterator && end = p->child_end();

    while(it != end) {
      result.push_back(new ActionConfig(it->first, *(it->second)));
      ++it;
    }
  }
}

__END_NS_SSRC_WSPR_WS

#endif