group_session/ws.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_GROUP_SESSION_WS_H
#define __SSRC_WSPR_GROUP_SESSION_WS_H

#include <ssrc/wispers/ws/protocol.h>
#include <ssrc/wispers/group_session/protocol.h>

__BEGIN_NS_SSRC_WSPR_GROUP_SESSION

using NS_SSRC_WSPR_WS::WebServiceCall;

WS_CALL_PARAM(param_find_sessions,
                  ((db_limit_type, limit))((db_offset_type, offset)));

template<typename CallType,
         typename ParamType, typename DestinationType, typename CallerType>
inline void call_find_sessions(CallerType & caller,
                               const WebServiceCall & call,
                               const ParamType & param,
                               const DestinationType & service,
                               const db_limit_type max_limit = 50)
{
  if(call.session) {
    db_limit_type limit(param.limit);
    db_offset_type offset(param.offset);

    if(limit > max_limit || limit < 1)
      limit = max_limit;
    if(offset < 0)
      offset = 0;
    caller.template
      sendp<CallType>(service, call.session->uid, limit, offset);
  }
}

template<typename ResultType, typename DestinationType, typename CallerType>
inline void
process_find_group_sessions_result(CallerType & caller,
                                   const ResultType & msg,
                                   const string & session_type,
                                   const DestinationType & event_queue)
{
  using NS_SSRC_WSPR_WS::WebServiceProtocol;
  using NS_SSRC_WSPR_WS::web_event_indirect;
  using NS_SSRC_WSPR_UTILITY::Properties;
  using NS_SSRC_WSPR_UTILITY::property_vector;

  WISP_IMPORT_T(WebServiceProtocol, MessageDeliverEvent);
  WISP_IMPORT_T(WebServiceProtocol, CallDeliverEvent);

  MessageDeliverEvent delivery;
  Properties & event =
    web_event_indirect(*delivery.template_data,
                       "wspr.GroupSession", "FindGroupSessions");

  delivery.keys.push_back(msg.requestor);

  event.set(msg.total_sessions, "total_sessions");
  event.set(msg.limit, "limit");
  event.set(msg.offset, "offset");
  event.set(session_type, "type");
  event.set(msg.gs_name, "gs_name");

  if(!msg.sessions.empty()) {
    property_vector & sessions = event.create_property_vector("sessions");

    for(group_session_container::const_iterator it = msg.sessions.begin(),
          end = msg.sessions.end(); it != end; ++it)
    {
      sessions.push_back(new Properties);
      bind_group_session_properties(*it, sessions.back());
    }
  }

  caller.template
    send<CallDeliverEvent>(event_queue, delivery);
}

__END_NS_SSRC_WSPR_GROUP_SESSION

#endif