bot_framework 0.1.0beta

data/lib/bot_framework/models/bot_data.rb

@@ -0,0 +1,15 @@
+module BotFramework
+  class BotData < Base
+    attr_accessor :data
+
+    attr_accessor :e_tag
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        data: :Object,
+        e_tag: :String
+      }
+    end
+  end
+end

data/lib/bot_framework/models/card_action.rb

@@ -0,0 +1,43 @@
+module BotFramework
+  class CardAction < Base
+    # Defines the type of action implemented by this button.
+    attr_accessor :type
+
+    # Text description which appear on the button.
+    attr_accessor :title
+
+    # URL Picture which will appear on the button, next to text label.
+    attr_accessor :image
+
+    # Supplementary parameter for action. Content of this property depends on the ActionType
+    attr_accessor :value
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        type: :String,
+        title: :String,
+        image: :String,
+        value: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.type = attributes[:type] if attributes.key?(:type)
+
+      self.title = attributes[:title] if attributes.key?(:title)
+
+      self.image = attributes[:image] if attributes.key?(:image)
+
+      self.value = attributes[:value] if attributes.key?(:value)
+    end
+  end
+end

data/lib/bot_framework/models/card_image.rb

@@ -0,0 +1,36 @@
+module BotFramework
+  class CardImage < Base
+    # URL Thumbnail image for major content property.
+    attr_accessor :url
+
+    # Image description intended for screen readers
+    attr_accessor :alt
+
+    # Action assigned to specific Attachment.E.g.navigate to specific URL or play/open media content
+    attr_accessor :tap
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        url: :String,
+        alt: :String,
+        tap: :CardAction
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.url = attributes[:url] if attributes.key?(:url)
+
+      self.alt = attributes[:alt] if attributes.key?(:alt)
+
+      self.tap = attributes[:tap] if attributes.key?(:tap)
+    end
+  end
+end

data/lib/bot_framework/models/channel_account.rb

@@ -0,0 +1,18 @@
+module BotFramework
+  # Channel account information needed to route a message
+  class ChannelAccount < Base
+    # Channel id for the user or bot on this channel (Example: joe@smith.com, or @joesmith or 123456)
+    attr_accessor :id
+
+    # Display friendly name
+    attr_accessor :name
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        id: :String,
+        name: :String
+      }
+    end
+  end
+end

data/lib/bot_framework/models/conversation_account.rb

@@ -0,0 +1,22 @@
+module BotFramework
+  # Channel account information for a conversation
+  class ConversationAccount < Base
+    # Is this a reference to a group
+    attr_accessor :is_group
+
+    # Channel id for the user or bot on this channel (Example: joe@smith.com, or @joesmith or 123456)
+    attr_accessor :id
+
+    # Display friendly name
+    attr_accessor :name
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        is_group: :BOOLEAN,
+        id: :String,
+        name: :String
+      }
+    end
+  end
+end

data/lib/bot_framework/models/conversation_parameters.rb

@@ -0,0 +1,46 @@
+module BotFramework
+  class ConversationParameters < Base
+    # IsGroup
+    attr_accessor :is_group
+
+    # The bot address for this conversation
+    attr_accessor :bot
+
+    # Members to add to the conversation
+    attr_accessor :members
+
+    # (Optional) Topic of the conversation (if supported by the channel)
+    attr_accessor :topic_name
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        is_group: :BOOLEAN,
+        bot: :ChannelAccount,
+        members: :'Array<ChannelAccount>',
+        topic_name: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.is_group = attributes[:isGroup] if attributes.key?(:isGroup)
+
+      self.bot = attributes[:bot] if attributes.key?(:bot)
+
+      if attributes.key?(:members)
+        if (value = attributes[:members]).is_a?(Array)
+          self.members = value
+        end
+      end
+
+      self.topic_name = attributes[:topicName] if attributes.key?(:topicName)
+    end
+  end
+end

data/lib/bot_framework/models/entity.rb

@@ -0,0 +1,26 @@
+
+module BotFramework
+  # Object of schema.org types
+  class Entity < Base
+    # Entity Type (typically from schema.org types)
+    attr_accessor :type
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        type: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.type = attributes[:type] if attributes.key?(:type)
+    end
+  end
+end

data/lib/bot_framework/models/fact.rb

@@ -0,0 +1,29 @@
+module BotFramework
+  # Set of key-value pairs. Advantage of this section is that key and value properties will be               rendered with default style information with some delimiter between them. So there is no need for developer to specify style information.
+  class Fact < Base
+    attr_accessor :key
+
+    attr_accessor :value
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        key: :String,
+        value: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.key = attributes[:key] if attributes.key?(:key)
+
+      self.value = attributes[:value] if attributes.key?(:value)
+    end
+  end
+end

data/lib/bot_framework/models/geo_coordinates.rb

@@ -0,0 +1,49 @@
+module BotFramework
+  # GeoCoordinates (entity type: \"https://schema.org/GeoCoordinates\")
+  class GeoCoordinates < Base
+    # Elevation of the location [WGS 84](https://en.wikipedia.org/wiki/World_Geodetic_System)
+    attr_accessor :elevation
+
+    # Latitude of the location [WGS 84](https://en.wikipedia.org/wiki/World_Geodetic_System)
+    attr_accessor :latitude
+
+    # Longitude of the location [WGS 84](https://en.wikipedia.org/wiki/World_Geodetic_System)
+    attr_accessor :longitude
+
+    # The type of the thing
+    attr_accessor :type
+
+    # The name of the thing
+    attr_accessor :name
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        elevation: :Float,
+        latitude: :Float,
+        longitude: :Float,
+        type: :String,
+        name: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.elevation = attributes[:elevation] if attributes.key?(:elevation)
+
+      self.latitude = attributes[:latitude] if attributes.key?(:latitude)
+
+      self.longitude = attributes[:longitude] if attributes.key?(:longitude)
+
+      self.type = attributes[:type] if attributes.key?(:type)
+
+      self.name = attributes[:name] if attributes.key?(:name)
+    end
+  end
+end

data/lib/bot_framework/models/hero_card.rb

@@ -0,0 +1,62 @@
+module BotFramework
+  class HeroCard < Base
+    # Title of the card
+    attr_accessor :title
+
+    # Subtitle of the card
+    attr_accessor :subtitle
+
+    # Text for the card
+    attr_accessor :text
+
+    # Array of i
+    attr_accessor :images
+
+    # Set of actions applicable to the current card
+    attr_accessor :buttons
+
+    # This action will be activated when user taps on the card itself
+    attr_accessor :tap
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        title: :String,
+        subtitle: :String,
+        text: :String,
+        images: :'Array<CardImage>',
+        buttons: :'Array<CardAction>',
+        tap: :CardAction
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.title = attributes[:title] if attributes.key?(:title)
+
+      self.subtitle = attributes[:subtitle] if attributes.key?(:subtitle)
+
+      self.text = attributes[:text] if attributes.key?(:text)
+
+      if attributes.key?(:images)
+        if (value = attributes[:images]).is_a?(Array)
+          self.images = value
+        end
+      end
+
+      if attributes.key?(:buttons)
+        if (value = attributes[:buttons]).is_a?(Array)
+          self.buttons = value
+        end
+      end
+
+      self.tap = attributes[:tap] if attributes.key?(:tap)
+    end
+  end
+end

data/lib/bot_framework/models/object.rb

@@ -0,0 +1,19 @@
+module BotFramework
+  class Object < Base
+    
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+  end
+end

data/lib/bot_framework/models/place.rb

@@ -0,0 +1,56 @@
+module BotFramework
+  # Place (entity type: \"https://schema.org/Place\")
+  class Place < Base
+    # Address of the place (may be `string` or complex object of type `PostalAddress`)
+    attr_accessor :address
+
+    # Geo coordinates of the place (may be complex object of type `GeoCoordinates` or `GeoShape`)
+    attr_accessor :geo
+
+    # Map to the place (may be `string` (URL) or complex object of type `Map`)
+    attr_accessor :has_map
+
+    # The type of the thing
+    attr_accessor :type
+
+    # The name of the thing
+    attr_accessor :name
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        address: :Object,
+        geo: :Object,
+        has_map: :Object,
+        type: :String,
+        name: :String
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.address = attributes[:address] if attributes.key?(:address)
+
+      self.geo = attributes[:geo] if attributes.key?(:geo)
+
+      self.has_map = attributes[:hasMap] if attributes.key?(:hasMap)
+
+      self.type = attributes[:type] if attributes.key?(:type)
+
+      self.name = attributes[:name] if attributes.key?(:name)
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properies with the reasons
+    def list_invalid_properties
+      invalid_properties = []
+      invalid_properties
+    end
+  end
+end

data/lib/bot_framework/models/receipt_card.rb

@@ -0,0 +1,78 @@
+module BotFramework
+  class ReceiptCard < Base
+    # Title of the card
+    attr_accessor :title
+
+    # Array of Receipt Items
+    attr_accessor :items
+
+    # Array of Fact Objects   Array of key-value pairs.
+    attr_accessor :facts
+
+    # This action will be activated when user taps on the card
+    attr_accessor :tap
+
+    # Total amount of money paid (or should be paid)
+    attr_accessor :total
+
+    # Total amount of TAX paid(or should be paid)
+    attr_accessor :tax
+
+    # Total amount of VAT paid(or should be paid)
+    attr_accessor :vat
+
+    # Set of actions applicable to the current card
+    attr_accessor :buttons
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        title: :String,
+        items: :'Array<ReceiptItem>',
+        facts: :'Array<Fact>',
+        tap: :CardAction,
+        total: :String,
+        tax: :String,
+        vat: :String,
+        buttons: :'Array<CardAction>'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.title = attributes[:title] if attributes.key?(:title)
+
+      if attributes.key?(:items)
+        if (value = attributes[:items]).is_a?(Array)
+          self.items = value
+        end
+      end
+
+      if attributes.key?(:facts)
+        if (value = attributes[:facts]).is_a?(Array)
+          self.facts = value
+        end
+      end
+
+      self.tap = attributes[:tap] if attributes.key?(:tap)
+
+      self.total = attributes[:total] if attributes.key?(:total)
+
+      self.tax = attributes[:tax] if attributes.key?(:tax)
+
+      self.vat = attributes[:vat] if attributes.key?(:vat)
+
+      if attributes.key?(:buttons)
+        if (value = attributes[:buttons]).is_a?(Array)
+          self.buttons = value
+        end
+      end
+    end
+  end
+end