lex_common.h

Go to the documentation of this file.

/*
 * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  http://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file 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 LEX_COMMON__LEX_COMMON_H_
#define LEX_COMMON__LEX_COMMON_H_

#include <aws_common/sdk_utils/client_configuration_provider.h>
#include <aws_common/sdk_utils/parameter_reader.h>

#include <aws/lex/LexRuntimeServiceClient.h>
#include <aws/lex/model/PostTextRequest.h>
#include <aws/lex/model/PostTextResult.h>
#include <aws/lex/model/PostContentRequest.h>
#include <aws/lex/model/PostContentResult.h>
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/HashingUtils.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/utils/logging/AWSLogging.h>
#include <aws/core/utils/logging/LogMacros.h>

#include <lex_common/error_codes.h>
#include <lex_common/lex_configuration.h>
#include <lex_common/lex_param_helper.h>

#include <algorithm>
#include <iostream>
#include <iterator>
#include <memory>
#include <string>
#include <regex>
#include <unordered_map>
#include <vector>

namespace Aws
{
namespace Lex
{

static const char * kAllocationTag = "lex";

struct LexRequest
{
  std::string accept_type;
  std::string text_request;
  std::vector<uint8_t> audio_request;
  std::string content_type;
};

struct LexResponse
{
  std::string text_response;
  std::string message_format_type;
  std::vector<uint8_t> audio_response;
  std::string intent_name;
  std::string dialog_state;
  std::unordered_map<std::string, std::string> slots;
  std::string session_attributes;
};

ErrorCode CopyResult(
  Aws::LexRuntimeService::Model::PostContentResult & result,
  LexResponse & response);

/*\@{*/
std::ostream & operator<<(
  std::ostream & os,
  const Aws::LexRuntimeService::Model::PostContentRequest & request);

std::ostream & operator<<(
  std::ostream & os,
  const Aws::LexRuntimeService::Model::PostContentResult & result);
/*\@}*/

class PostContentInterface
{
public:
  virtual ErrorCode PostContent(
    const LexRequest & request,
    LexResponse & response) = 0;
};

class LexInteractor : public PostContentInterface
{
protected:
  std::shared_ptr<LexConfiguration> lex_configuration_;

  std::shared_ptr<Aws::LexRuntimeService::LexRuntimeServiceClient> lex_runtime_client_;

public:
  ErrorCode ConfigureAwsLex(
    std::shared_ptr<LexConfiguration> lex_configuration,
    std::shared_ptr<Aws::LexRuntimeService::LexRuntimeServiceClient> lex_runtime_client);

  ErrorCode PostContent(
    const LexRequest & request,
    LexResponse & response) override;
};

inline ErrorCode BuildLexInteractor(
  std::shared_ptr<Client::ParameterReaderInterface> params,
  LexInteractor & lex_interactor)
{
  ErrorCode result;
  auto lex_configuration = std::make_shared<LexConfiguration>();
  result = LoadLexParameters(*params, *lex_configuration);
  if (result != SUCCESS) {
    return result;
  }
  Client::ClientConfigurationProvider configuration_provider(params);
  auto lex_runtime_client = Aws::MakeShared<Aws::LexRuntimeService::LexRuntimeServiceClient>(
    kAllocationTag, configuration_provider.GetClientConfiguration());
  lex_interactor = LexInteractor();
  lex_interactor.ConfigureAwsLex(lex_configuration, lex_runtime_client);
  return result;
}

}  // namespace Lex
}  // namespace Aws

#endif  // LEX_COMMON__LEX_COMMON_H_