phpfog-fog 0.4.1

data/lib/fog/aws/requests/ses/get_send_statistics.rb

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class SES
+      class Real
+
+        require 'fog/aws/parsers/ses/get_send_statistics'
+
+        # Returns the user's current activity limits.
+        #
+        # ==== Parameters
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'GetSendStatisticsResult'<~Hash>
+        #       * 'SendDataPoints' <~Array>
+        #         * 'Bounces' <~String>
+        #         * 'Complaints' <~String>
+        #         * 'DeliveryAttempts' <~String>
+        #         * 'Rejects' <~String>
+        #         * 'Timestamp' <~String>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def get_send_statistics
+          request({
+            'Action' => 'GetSendStatistics',
+            :parser  => Fog::Parsers::AWS::SES::GetSendStatistics.new
+          })
+        end
+
+      end
+
+      class Mock
+
+        def get_send_statistics
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/ses/list_verified_email_addresses.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class SES
+      class Real
+
+        require 'fog/aws/parsers/ses/list_verified_email_addresses'
+
+        # Returns a list containing all of the email addresses that have been verified
+        #
+        # ==== Parameters
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ListVerifiedEmailAddressesResult'<~Hash>
+        #       * 'VerifiedEmailAddresses' <~Array>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def list_verified_email_addresses
+          request({
+            'Action' => 'ListVerifiedEmailAddresses',
+            :parser  => Fog::Parsers::AWS::SES::ListVerifiedEmailAddresses.new
+          })
+        end
+
+      end
+
+      class Mock
+
+        def list_verified_email_addresses
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/ses/send_email.rb

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class SES
+      class Real
+
+        require 'fog/aws/parsers/ses/send_email'
+
+        # Delete an existing verified email address
+        #
+        # ==== Parameters
+        # * Destination <~Hash> - The destination for this email, composed of To:, From:, and CC: fields.
+        #   * BccAddresses <~Array> - The BCC: field(s) of the message.
+        #   * CcAddresses <~Array> - The CC: field(s) of the message.
+        #   * ToAddresses <~Array> - The To: field(s) of the message.
+        # * Message <~Hash> - The message to be sent.
+        #   * Body <~Hash>
+        #     * Html <~Hash>
+        #       * Charset <~String>
+        #       * Data <~String>
+        #     * Text <~Hash>
+        #       * Charset <~String>
+        #       * Data <~String>
+        #   * Subject <~Hash>
+        #     * Charset <~String>
+        #     * Data <~String>
+        # * ReplyToAddresses <~Array> - The reply-to email address(es) for the message. If the recipient replies to the message, each reply-to address will receive the reply.
+        # * ReturnPath <~String> - The email address to which bounce notifications are to be forwarded. If the message cannot be delivered to the recipient, then an error message will be returned from the recipient's ISP; this message will then be forwarded to the email address specified by the ReturnPath parameter.
+        # * Source <~String> - The sender's email address
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'DeleteVerfiedEmailAddressResponse'<~nil>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def send_email()
+          params = AWS.indexed_param('ReplyToAddresses.member', [*reply_to_addresses])
+
+          request({
+            'Action'           => 'DeleteVerifiedEmailAddress',
+            'EmailAddress'     => email_address,
+            :parser            => Fog::Parsers::AWS::SES::DeleteVerifiedEmailAddress.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def delete_verified_email_address(email_address)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/ses/send_raw_email.rb

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class SES
+      class Real
+
+        require 'fog/aws/parsers/ses/send_raw_email'
+
+        # Delete an existing verified email address
+        #
+        # ==== Parameters
+        # * Destinations <~Array> - The destination for this email, composed of To:, From:, and CC: fields.
+        # * RawMessage <~Hash> - The message to be sent.
+        #   * Data <~String>
+        # * Source <~String> - The sender's email address
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'DeleteVerfiedEmailAddressResponse'<~nil>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def send_raw_email()
+          # TODO: Make this work
+          params = AWS.indexed_param('ReplyToAddresses.member', [*reply_to_addresses])
+
+          request({
+            'Action'           => 'SendRawEmail',
+            :parser            => Fog::Parsers::AWS::SES::SendRawEmail.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def send_raw_email()
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/ses/verify_email_address.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class SES
+      class Real
+
+        require 'fog/aws/parsers/ses/verify_email_address'
+
+        # Verifies an email address. This action causes a confirmation email message to be sent to the specified address.
+        #
+        # ==== Parameters
+        # * email_address<~String> - The email address to be verified
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'VerifyEmailAddressResult'<~nil>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def verify_email_address(email_address)
+          request({
+            'Action'           => 'VerifyEmailAddress',
+            'EmailAddress'     => email_address,
+            :parser            => Fog::Parsers::AWS::SES::VerifyEmailAddress.new
+          })
+        end
+
+      end
+
+      class Mock
+
+        def verify_email_address(email_address)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/batch_put_attributes.rb

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        # Put items attributes into a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * items<~Hash> - Keys are the items names and may use any UTF-8
+        #   characters valid in xml.  Control characters and sequences not allowed
+        #   in xml are not valid.  Can be up to 1024 bytes long.  Values are the
+        #   attributes to add to the given item and may use any UTF-8 characters
+        #   valid in xml. Control characters and sequences not allowed in xml are
+        #   not valid.  Each name and value can be up to 1024 bytes long.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          request({
+            'Action'      => 'BatchPutAttributes',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          }.merge!(encode_batch_attributes(items, replace_attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            for item_name, attributes in items do
+              for key, value in attributes do
+                @data[:domains][domain_name][item_name] ||= {}
+                if replace_attributes[item_name] && replace_attributes[item_name].include?(key)
+                  @data[:domains][domain_name][item_name][key.to_s] = []
+                else
+                  @data[:domains][domain_name][item_name][key.to_s] ||= []
+                end
+                @data[:domains][domain_name][item_name][key.to_s] << value.to_s
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/create_domain.rb

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        # Create a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # 
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def create_domain(domain_name)
+          request(
+            'Action'      => 'CreateDomain',
+            'DomainName'  => domain_name,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_domain(domain_name)
+          response = Excon::Response.new
+          @data[:domains][domain_name] = {}
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/delete_attributes.rb

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Hash> - Name/value pairs to remove from the item.  Defaults to
+        #   nil, which will delete the entire item. Attribute names and values may
+        #   use any UTF-8 characters valid in xml. Control characters and sequences
+        #   not allowed in xml are not valid.  Each name and value can be up to 1024
+        #   bytes long.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          request({
+            'Action'      => 'DeleteAttributes',
+            'DomainName'  => domain_name,
+            'ItemName'    => item_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          }.merge!(encode_attributes(attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            if attributes
+              for key, value in attributes
+                if @data[:domains][domain_name][key]
+                  @data[:domains][domain_name][key].delete('value')
+                end
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/delete_domain.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        # Delete a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # 
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_domain(domain_name)
+          request(
+            'Action'      => 'DeleteDomain',
+            'DomainName'  => domain_name,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_domain(domain_name)
+          response = Excon::Response.new
+          if @data[:domains].delete(domain_name)
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/domain_metadata.rb

@@ -0,0 +1,76 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/domain_metadata'
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'AttributeNameCount' - number of unique attribute names in domain
+        #     * 'AttributeNamesSizeBytes' - total size of unique attribute names, in bytes
+        #     * 'AttributeValueCount' - number of all name/value pairs in domain
+        #     * 'AttributeValuesSizeBytes' - total size of attributes, in bytes
+        #     * 'BoxUsage'
+        #     * 'ItemCount' - number of items in domain
+        #     * 'ItemNameSizeBytes' - total size of item names in domain, in bytes
+        #     * 'RequestId'
+        #     * 'Timestamp' - last update time for metadata.
+        def domain_metadata(domain_name)
+          request(
+            'Action'      => 'DomainMetadata',
+            'DomainName'  => domain_name,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::SimpleDB::DomainMetadata.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def domain_metadata(domain_name)
+          response = Excon::Response.new
+          if domain = @data[:domains][domain_name]
+            response.status = 200
+          
+            attribute_names = []
+            attribute_values = []
+            for item in domain.values
+              for key, values in item
+                attribute_names << key
+                for value in values
+                  attribute_values << value
+                end
+              end
+            end
+          
+            response.body = {
+              'AttributeNameCount'        => attribute_names.length,
+              'AttributeNamesSizeBytes'   => attribute_names.join('').length,
+              'AttributeValueCount'       => attribute_values.length,
+              'AttributeValuesSizeBytes'  => attribute_values.join('').length,
+              'BoxUsage'                  => Fog::AWS::Mock.box_usage,
+              'ItemCount'                 => domain.keys.length,
+              'ItemNamesSizeBytes'        => domain.keys.join('').length,
+              'RequestId'                 => Fog::AWS::Mock.request_id,
+              'Timestamp'                 => Time.now
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/get_attributes.rb

@@ -0,0 +1,72 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/get_attributes'
+
+        # List metadata for SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Array> - Attributes to return from the item.  Defaults to
+        #   {}, which will return all attributes. Attribute names and values may use
+        #   any UTF-8 characters valid in xml. Control characters and sequences not 
+        #   allowed in xml are not valid.  Each name and value can be up to 1024
+        #   bytes long.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Attributes' - list of attribute name/values for the item
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def get_attributes(domain_name, item_name, attributes = {})
+          
+          request({
+            'Action'      => 'GetAttributes',
+            'DomainName'  => domain_name,
+            'ItemName'    => item_name,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::SimpleDB::GetAttributes.new(@nil_string)
+          }.merge!(encode_attribute_names(attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def get_attributes(domain_name, item_name, attributes = nil)
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            object = {}
+            if attributes
+              for attribute in attributes
+                if @data[:domains][domain_name][item_name] && @data[:domains][domain_name][item_name]
+                  object[attribute] = @data[:domains][domain_name][item_name][attribute]
+                end
+              end
+            elsif @data[:domains][domain_name][item_name]
+              object = @data[:domains][domain_name][item_name]
+            end
+            response.status = 200
+            response.body = {
+              'Attributes'  => object,
+              'BoxUsage'    => Fog::AWS::Mock.box_usage,
+              'RequestId'   => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/list_domains.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/list_domains'
+
+        # List SimpleDB domains
+        #
+        # ==== Parameters
+        # * options<~Hash> - options, defaults to {}
+        #   * 'MaxNumberOfDomains'<~Integer> - number of domains to return
+        #     between 1 and 100, defaults to 100
+        #   * 'NextToken'<~String> - Offset token to start listing, defaults to nil
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'Domains' - array of domain names.
+        #     * 'NextToken' - offset to start with if there are are more domains to list
+        #     * 'RequestId'
+        def list_domains(options = {})
+          request({
+            'Action'    => 'ListDomains',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::SimpleDB::ListDomains.new(@nil_string)
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def list_domains(options = {})
+          response = Excon::Response.new
+          keys = @data[:domains].keys
+          max = options['MaxNumberOfDomains'] || keys.size
+          offset = options['NextToken'] || 0
+          domains = []
+          for key, value in @data[:domains].keys[offset...max]
+            domains << key
+          end
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'Domains'   => domains,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          if max < keys.size
+            response.body['NextToken'] = max + 1
+          end
+          response
+        end
+
+      end
+    end
+  end
+end