ruby-cakemail 0.0.1

data/README.rdoc

@@ -0,0 +1 @@
+== To be written.

data/lib/cakemail/campaign.rb

@@ -0,0 +1,83 @@
+# A Campaign is a group of Mailings.
+#
+# A Campaign cannot be closed if any mailings are Incomplete, Scheduled or Delivering.
+#
+# A Campaign can be deleted only if it does not contain a Mailing.
+module CakeMail
+  module API
+    class ClassCampaign < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :name, :user_key ]
+      method :name => "Delete", :requires => [ :campaign_id, :user_key ]
+      method :name => "GetInfo", :requires => [ :campaign_id, :user_key ]
+      method :name => "GetList", :requires => [ :user_key ], :optional => [ :count, :limti, :offset, :status ]
+      method :name => "SetInfo", :requires => [ :campaign_id, :user_key ], :optional => [ :name, :status ]
+    end
+  end
+
+  class Campaign
+    attr_reader :client_id, :closed_on, :created_on, :id, :session, :user
+    attr_accessor :name, :status
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Deletes a campaign.  
+    def delete
+      @user.session.request("CakeMail::API::ClassCampaign", "Delete", { :campaign_id => @id, :user_key => @user.user_key })
+      self.freeze
+    end
+    # Returns information about a campaign.  
+    def get_info(id = @id)
+      res = @user.session.request("CakeMail::API::ClassCampaign", "GetInfo", { :campaign_id => id, :user_key => @user.user_key })
+      @client_id = res['client_id'].first
+      @closed_on = res['closed_on'].first
+      @created_on = res['created_on'].first
+      @id = res['id'].first
+      @name = res['name'].first
+      @status = res['status'].first
+    end
+    # Retreives a mailing by id.
+    def mailing(id)
+      return CakeMail::Mailing.new(self, id)
+    end
+    # Creates a new mailing.
+    def mailing_new(name)
+      return CakeMail::Mailing.create(self, name)
+    end
+    
+    def save
+      self.setinfo
+    end
+    # Modifies a campaign.
+    def set_info
+      args = { :campaign_id => id, :user_key => @user.user_key }
+      args[:name] = @name unless @name.nil?
+      args[:status] = @status unless @status.nil?
+      res = @user.session.request("CakeMail::API::ClassCampaign", "SetInfo", args)
+    end
+    
+    class << self
+      # Creates a new campaign.  
+      def create(name, user)
+         res = user.session.request("CakeMail::API::ClassCampaign", "Create", { :name => name, :user_key => user.user_key })
+         Campaign.new(res['id'].first, user)
+      end
+      # Retrieves the list of campaigns.  
+      #
+      # Arguments :
+      # * args = { :user => required, :limit => optional, :offset => optional, :status => optional }
+      def get_list(args)
+        raise ArgumentError if args.nil? or args[:user].nil?
+        options = { :user_key => args[:user].user_key }
+        options[:limit] = args[:limit] unless args[:limit].nil?
+        options[:offset] = args[:offset] unless args[:offset].nil?
+        options[:status] = args[:status] unless args[:status].nil?
+        res = args[:user].session.request("CakeMail::API::ClassCampaign", "GetList", options)
+        res['campaign']
+      end
+    end
+  end
+end
+

data/lib/cakemail/client.rb

@@ -0,0 +1,161 @@
+# A Client is an account and is created for every Organization that uses CakeMail's services. An Admin User is created at the same time as 
+# the Client. Each Client (Account) may have as many Users as required. The Admin controls the permissions of each user within the Client 
+# account. Also, a Contact User may be created at the same time as the Admin User, upon creation of the Client Account. The Contact user is 
+# a secondary User. If no Contact User is entered, the Admin User is set as the default Contact User.
+#
+# Each Client has a Client ID. When creating a Child Client, use the Master Client ID as the "parent_id" upon creation of the new Client 
+# Account. The new Client Account will then be recognized as a Child Account of the Master.
+module CakeMail
+  module API
+    class ClassClient < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :admin_email, :admin_first_name, :admin_last_name, :admin_password,
+          :admin_password_confirmation, :company_name, :contact_email, :contact_first_name, :contact_last_name, :contact_password,
+          :contact_password_confirmation ],
+          :optional => [ :parent_id, :currency, :address1, :address2, :city, :province_id, :postal_code, :country_id,
+          :website, :phone, :fax, :contact_same_as_admin, :admin_title, :admin_office_phone, :admin_mobile_phone,
+          :admin_language, :admin_timezone_id, :contact_title, :contact_language, :contact_timezone_id, :contact_office_phone,
+          :contact_mobile_phone ]
+      method :name => "Activate", :requires => [ :confirmation ]
+      method :name => "GetTimezones"
+      method :name => "GetInfo", :requires => [ :client_id, :user_key ]
+      method :name => "GetList", :optional => [ :status, :limit, :offset, :count, :user_key ]
+      method :name => "SetInfo", :requires => [ :user_key ], :optional => [ :client_id, :status, :manager_id, :parent_id, :contact_id,
+          :company_name, :address1, :address2, :city, :province_id, :postal_code, :country_id, :website, :phone, :fax, :user_key ]
+    end
+  end
+
+  class Client
+    attr_reader :session, :id, :client_id, :manager_id, :parent_id, :province_id, :country_id, :contact_id, :contact_timezone_id,
+        :limit, :registered_date, :last_activity
+    attr_accessor :company_name, :admin_email, :admin_first_name, :admin_last_name, :admin_password, :contact_email,
+        :contact_first_name, :contact_last_name, :contact_password, :currency, :address1, :address2, :city,
+        :postal_code, :website, :phone, :fax, :admin_title, :admin_office_phone, :admin_mobile_phone,
+        :admin_language, :contact_title, :contact_language, :contact_office_phone, :contact_mobile_phone
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Returns information about a client.  
+    def get_info(id = @id)
+      @user.session.request("CakeMail::API::ClassClient", "GetInfo", { :client_id => @id, :user_key => @user.user_key })
+      @registered_date = res['registered_date'].first
+      @last_activity = res['last_activity'].first
+      @manager_id = res['manager_id'].first
+      @parent_id = res['parent_id'].first
+      @contact_id = res['contact_id'].first
+      @province_id = res['province_id'].first
+      @country_id = res['country_id'].first
+      @limit = res['limit'].first
+      @status = res['status'].first
+      @currency = res['currency'].first
+      @company_name = res['company_name'].first
+      @address1 = res['address1'].first
+      @address2 = res['address2'].first
+      @city = res['city'].first
+      @postal_code = res['postal_code'].first
+      @website = res['website'].first
+      @phone = res['phone'].first
+      @fax = res['fax'].first
+    end
+    
+    def save
+      set_info
+    end
+    # Modifies a client.  
+    def set_info(client_id = nil)
+      args = { :user_key => @user.user_key }
+      if !client_id.nil?
+        args[:client_id] = client_id
+      else
+        args[:client_id] = @id unless @id.nil?
+      end
+      args[:status] = @status unless @status.nil?
+      args[:manager_id] = @manager_id unless @manager_id.nil?
+      args[:parent_id] = @parent_id unless @parent_id.nil?
+      args[:contact_id] = @contact_id unless @contact_id.nil?
+      args[:company_name] = @company_name unless @company_name.nil?
+      args[:address1] = @address1 unless @address1.nil?
+      args[:address2] = @address2 unless @address2.nil?
+      args[:city] = @city unless @city.nil?
+      args[:province_id] = @province_id unless @province_id.nil?
+      args[:postal_code] = @postal_code unless @postal_code.nil?
+      args[:country_id] = @country_id unless @country_id.nil?
+      args[:website] = @website unless @website.nil?
+      args[:phone] = @phone unless @phone.nil?
+      args[:fax] = @fax unless @fax.nil?
+      @user.session.request("CakeMail::API::ClassClient", "SetInfo", args)
+    end
+
+    class << self
+      # Creates a new client. 
+      #
+      # Arguments : 
+      # * args = { :user => required, :company_name => required, :admin_email => required, :admin_first_name => required, 
+      #   :admin_last_name => required, :admin_password => required, :contact_email => required, :contact_first_name => required, 
+      #   :contact_last_name => required, :contact_password => required, :parent_id => optional, :currency => optional, :address1 => optional, 
+      #   :address2 => optionall, :city => optional, :province_id => optional, :country_id => optional, :postal_code => optional, 
+      #   :website => optional, :phone => optional, :fax => optional, :admin_title => optional, :admin_office_phone => required, 
+      #   :admin_mobile_phone => optional, :admin_language => optional, :contact_title => optional, :contact_language => optional, 
+      #   :contact_timezone_id => optional, :contact_office_phone => optional, :contact_mobile_phone => optional }
+      def create(args)
+        raise ArgumentError if args.nil? or args[:user].nil? or args[:company_name].nil? or args[:admin_email].nil? or 
+          args[:admin_first_name].nil? or args[:admin_last_name].nil? or args[:admin_password].nil? or args[:contact_email].nil? or
+          args[:contact_first_name].nil? or args[:contact_last_name].nil? or args[:contact_password].nil?
+        options = { :company_name => args[:company_name], :admin_email => args[:admin_email], :admin_first_name => args[:admin_first_name],
+            :admin_last_name => args[:admin_last_name], :admin_password => args[:admin_password],
+            :admin_password_confirmation => args[:admin_password_confirmation], :contact_email => args[:contact_email],
+            :contact_first_name => args[:contact_first_name], :contact_last_name => args[:contact_last_name],
+            :contact_password => args[:contact_password], :contact_password_confirmation => args[:contact_password_confirmation] }
+        options[:parent_id] = args[:parent_id] unless args[:parent_id].nil?
+        options[:currency] = args[:currency] unless args[:currency].nil?
+        options[:address1] = args[:address1] unless args[:address1].nil?
+        options[:address2] = args[:address2] unless args[:address2].nil?
+        options[:city] = args[:city] unless args[:city].nil?
+        options[:province_id] = args[:province_id] unless args[:province_id].nil?
+        options[:postal_code] = args[:postal_code] unless args[:postal_code].nil?
+        options[:country_id] = args[:country_id] unless args[:country_id].nil?
+        options[:website] = args[:website] unless args[:website].nil?
+        options[:phone] = args[:phone] unless args[:phone].nil?
+        options[:fax] = args[:fax] unless args[:fax].nil?
+        options[:admin_title] = args[:admin_title] unless args[:admin_title].nil?
+        options[:admin_office_phone] = args[:admin_office_phone] unless args[:admin_office_phone].nil?
+        options[:admin_mobile_phone] = args[:admin_mobile_phone] unless args[:admin_mobile_phone].nil?
+        options[:admin_language] = args[:admin_language] unless args[:admin_language].nil?
+        options[:admin_timezone_id] =args[:admin_timezone_id] unless args[:admin_timezone_id].nil?
+        options[:admin_language] = args[:admin_language] unless args[:admin_language].nil?
+        options[:contact_title] = args[:contact_title] unless args[:contact_title].nil?
+        options[:contact_language] = args[:contact_language] unless args[:contact_language].nil?
+        options[:contact_timezone_id] = args[:contact_timezone_id] unless args[:contact_timezone_id].nil?
+        options[:contact_office_phone] = args[:contact_office_phone] unless args[:contact_office_phone].nil?
+        options[:contact_mobile_phone] = args[:contact_mobile_phone] unless args[:contact_mobile_phone].nil?
+        res = args[:user].session.request("CakeMail::API::ClassClient", "Create", options)
+        res = args[:user].session.request("CakeMail::API::ClassClient", "Activate", { :confirmation => res['confirmation'].first })
+        return Client.new(id, args[:user])
+      end
+      # Retrieves the list of clients.
+      #
+      # Arguments :  
+      # * args = { :user => required, :count => optional, :status => optional, :limit => optional, :offset => optional }   
+      def get_list(args)
+        raise ArgumentError if args.nil? or args[:user].nil?
+        options = { :user_key => args[:user].user_key }
+        options[:count] = args[:count] unless args[:count].nil?
+        options[:status] = args[:status] unless args[:status].nil?
+        options[:limit] = args[:limit] unless args[:limit].nil?
+        options[:offset] = args[:offset] unless args[:offset].nil?
+        res = args[:user].session.request("CakeMail::API::ClassClient", "GetList", options)
+        if !args[:count].nil?
+          return res['count'].first
+        end
+        return res['client']
+      end
+      # Returns the list with the supported timezones.  
+      def get_timezones(user)
+        res = user.session.request("CakeMail::API::ClassClient", "GetTimezones", {})
+        res['timezone']
+      end
+    end
+  end
+end

data/lib/cakemail/country.rb

@@ -0,0 +1,23 @@
+module CakeMail
+  module API
+    class ClassCountry < CakeMail::ServiceClass
+      method :name => "GetList"
+      method :name => "GetProvinces", :requires => [ :country_id, :user_key ]
+    end
+  end
+  
+  class Country
+    class << self
+      # Retrieves the list of countries.  
+      def get_list(session)
+        res = session.request("CakeMail::API::ClassCountry", "GetList", { })
+        return res['country']
+      end
+      # Retrieves the list of provinces for a country (only us and ca for the moment).  
+      def get_provinces(country_id, user)
+        res = session.request("CakeMail::API::ClassCountry", "GetProvinces", { :country_id => country_id, :user_key => user.user_key })
+        return res['province']
+      end
+    end
+  end
+end

data/lib/cakemail/group.rb

@@ -0,0 +1,102 @@
+# Permission Groups are a set of permissions which allow the Administrator to define User permission profiles.
+#
+# A single User may be assigned to multiple Permission Groups, and is assigned the cumulative permissions of all groups.
+module CakeMail
+  module API
+    class ClassGroup < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :name, :user_key ], :optional => [ :client_id ]
+      method :name => "Delete", :requires => [ :group_id, :user_key ]
+      method :name => "GetInfo", :requires => [ :group_id, :user_key ], :optional => [ :client_id ]
+      method :name => "SetInfo", :requires => [ :group_id, :user_key ], :optional => [ :client_id, :name ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:data].nil?
+            args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+          end
+        end 
+        ]
+      method :name => "GetList", :requires => [ :user_key ], :optional => [ :client_id, :limit, :offset, :count ]
+      method :name => "AddUser", :requires => [ :group_id, :user_id ], :optional => [ :client_id ]
+      method :name => "RemoveUser", :requires => [ :group_id, :user_id, :user_key ], :optional => [ :client_id ]
+    end
+  end
+
+  class Group
+    attr_reader :permission, :id
+    attr_accessor :client_id, :name
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Adds a user into a group.  
+    def add_user(user_id, client_id = nil)
+      args = { :user_id => user_id, :group_id => @id, :user_key => @user.user_key }
+      args[:client_id] = client_id unless client_id.nil?
+      @user.session.request("CakeMail::API::ClassGroup", "AddUser", args)
+    end
+    # Removes a user from a group.  
+    def remove_user(user_id, client_id = nil)
+      args = { :user_id => user_id, :group_id => @id, :user_key => @user.user_key }
+      args[:client_id] = client_id unless client_id.nil?
+      @user.session.request("CakeMail::API::ClassGroup", "RemoveUser", args)
+    end
+    # Deletes a group.  
+    def delete(client_id = nil)
+      args = { :group_id => @id, :user_key => @user.user_key }
+      args[:client_id] = client_id unless client_id.nil?
+      @user.session.request("CakeMail::API::ClassGroup", "Delete", args)
+      self.freeze
+    end
+    # Returns information about a group.  
+    def get_info(id = @id, client_id = nil)
+      args = { :group_id => @id, :user_key => @user.user_key }
+      args[:client_id] = client_id unless client_id.nil?
+      res = @user.session.request("CakeMail::API::ClassCampaign", "GetInfo", args)
+      @id = res['id'].first
+      @name = res['name'].first
+      @permission = res['permission']
+    end
+    
+    def save
+      self.setinfo
+    end
+    # Modifies a group.
+    #
+    # Custom argument:
+    # * data = [ { :type => "CLASS_USER_CREATE", :value => "1" }, { :type => "CLASS_USER_SET_INFO", :value => "0" }, ... ]  
+    def set_info(data = nil)
+      args = { :group_id => @id, :user_key => @user.user_key }
+      args[:client_id] = client_id unless client_id.nil?
+      args[:name] = name unless name.nil?
+      args[:data] = date unless data.nil?
+      res = @user.session.request("CakeMail::API::ClassCampaign", "SetInfo", args)
+    end
+    
+    class << self
+      # Creates a group.  
+      def create(user, name, client_id = nil)
+        args = { :name => name, :user_key => user.user_key }
+        args[:client_id] = client_id unless client_id.nil?
+        res = user.session.request("CakeMail::API::ClassGroup", "Create", args)
+        Group.new(user, { :id => res['id'].first })
+      end
+      # Retrieves the list of groups.  
+      #
+      # Arguments :
+      # * args = { :user => required, :client_id => optional, :count => optional, :limit => optional, :offset => optional }
+      def get_list(args)
+        options = { :user_key => args[:user].user_key }
+        options[:count] = args[:count] unless args[:count].nil?
+        options[:client_id] = args[:client_id] unless args[:client_id].nil?
+        options[:limit] = args[:limit] unless args[:limit].nil?
+        options[:offset] = args[:offset] unless args[:offset].nil?
+        res = args[:user].session.request("CakeMail::API::ClassCampaign", "GetList", options)
+        if !args[:count].nil?
+          return res['count'].first
+        end
+        return res['campaign']
+      end
+    end
+  end
+end

data/lib/cakemail/list.rb

@@ -0,0 +1,336 @@
+# A List is a collection of subscribers (or List Members, or Records). Each subscriber or List Member is uniquely identified by their email
+# address, and may include an unlimited amount of Fields containing demographic information associated to each email address.
+#
+# A Contact List may have the following status:
+#
+# * Active => Displayed on the main page of the Contact Lists tab and is available for Mailings
+# * Archived => Displayed on the Archived page of the Contact Lists tab and unavailable for Mailings
+#
+# List Member or Subscriber
+#
+# A List Member is an individual included in a Contact List. List Member is uniquely identified by their email address, and may include an
+# unlimited amount of Fields containing demographic information associated to each email address. Any individual email address may only be 
+# included once in a Contact List. An individual email address may be included in an unlimited number of Contact Lists.
+#
+# A List Member my have the following status:
+#
+# * Active => Members who are available to receive Mailings
+# * Unsubscribed => Members that have requested not to be sent future Mailings
+# * Bounced => Members whose email was identified as invalid
+# * Deleted => Members removed by a User
+# * Pending => Members who subscribed to a Double Opt-In List, and that have yet to confirm their Active subscription status
+#
+# Segmentation and Sub-lists
+#
+# Segmentation is the process of dividing a Contact List into Sub-Lists (Segments). Segments can be defined by any criteria within Contact 
+# List Field values. Segments can be defined by a Field starting or ending with, containing, equal or not equal to, greater or less than, 
+# any given value.
+module CakeMail
+  module API
+    class ClassList < CakeMail::ServiceClass
+      method :name => "AddTestEmail", :requires => [ :list_id, :email, :user_key ]
+      method :name => "Create", :requires => [ :name, :sender_name, :sender_email, :user_key ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:data].nil?
+            args[:data].each { |r| builder.data({ :type => r[:type] }, r[:name]) }
+          end
+        end 
+        ]
+      method :name => "CreateSublist", :requires => [ :sublist_name, :list_id, :user_key ], :custom_args_xml => [
+          Proc.new do |builder, args|
+            unless args[:data].nil?
+              args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+            end
+          end 
+          ]
+      method :name => "Delete", :requires => [ :list_id, :user_key ]
+      method :name => "DeleteEmail", :requires => [ :list_id, :email, :user_key ]
+      method :name => "DeleteRecord", :requires => [ :list_id, :record_id, :user_key ]
+      method :name => "DeleteSublist", :requires => [ :sublist_id, :user_key ]
+      method :name => "DeleteTestEmail", :requires => [ :list_id, :test_email_id, :user_key]
+      method :name => "EditStructure", :requires => [ :list_id, :action, :field, :user_key ], :optional => [ :type ]
+      method :name => "GetFields", :requires => [ :list_id, :user_key ]
+      method :name => "GetInfo", :requires => [ :list_id, :user_key ]
+      method :name => "GetList", :requires => [ :user_key ], :optional => [ :status, :limit, :offset, :count ]
+      method :name => "GetRecord", :requires => [ :list_id, :record_id, :user_key ], :optional => [ :record_key ]
+      method :name => "GetSublists", :requires => [ :list_id, :user_key ]
+      method :name => "GetTestEmails", :requires => [ :list_id, :user_key ]
+      method :name => "Import", :requires => [ :list_id, :user_key ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:record].nil?
+            args[:record].each do |r|
+              builder.record do |rec_builder|
+                r[:data].each { |d| rec_builder.data({ :type => d[:type] }, d[:value]) }
+              end
+            end
+          end
+        end 
+        ]
+      method :name => "Search", :requires => [ :list_id, :user_key ], :optional => [ :limit, :offset, :count ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:data].nil?
+            args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+          end
+        end 
+        ]
+      method :name => "SetInfo", :requires => [ :list_id, :user_key ], :optional => [ :sublist_id, :name, :query, :language, :status,
+          :policy, :sender_name, :sender_email, :forward_page, :goto_oi, :goto_di, :goto_oo ]
+      method :name => "Show", :requires => [ :list_id, :status, :user_key ], :optional => [ :bounce_type, :limit, :offset, :count ]
+      method :name => "SubscribeEmail", :requires => [ :list_id, :email, :user_key ], :optional => [ :no_triggers ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:data].nil?
+            args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+          end
+        end 
+        ]
+      method :name => "TestSublist", :requires => [ :list_id, :user_key ], :custom_args_xml => [
+          Proc.new do |builder, args|
+            unless args[:data].nil?
+              args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+            end
+          end 
+          ]
+      method :name => "UnsubscribeEmail", :requires => [ :list_id, :email, :user_key ]
+      method :name => "UpdateRecord", :requires => [ :list_id, :record_id, :user_key ], :custom_args_xml => [
+        Proc.new do |builder, args|
+          unless args[:data].nil?
+            args[:data].each { |r| builder.data({ :type => r[:type] }, r[:value]) }
+          end
+        end 
+        ]
+    end
+  end
+
+  class List
+    attr_reader :created_on, :pending, :active, :bounced, :unsubscribes, :id
+    attr_accessor :sublist_id, :name, :query, :language, :status, :policy, :sender_name, :sender_email, :forward_page, :goto_oi, 
+      :goto_di, :goto_oo
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Deletes a list.  
+    def delete
+      @user.session.request("CakeMail::API::ClassList", "Delete", { :list_id => @id, :user_key => @user.user_key })
+      self.freeze
+    end
+    # Retrieves informations about a list.  
+    def get_info(id = @id)
+      res = @user.session.request("CakeMail::API::ClassList", "GetInfo", { :list_id => id, :user_key => @user.user_key })
+      res = res['list'].first
+      @active = res['active'].first
+      @bounced = res['bounced'].first
+      @created_on = res['created_on'].first
+      @deleted = res['deleted'].first
+      @forward_page = res['forward_page'].first
+      @goto_di = res['goto_di'].first
+      @goto_oi = res['goto_oi'].first
+      @goto_oo = res['goto_oo'].first
+      @langauge = res['language'].first
+      @list_id = res['id'].first
+      @name = res['name'].first
+      @pending = res['pending'].first
+      @policy = res['policy'].first
+      @sender_email = res['sender_email'].first
+      @sender_name = res['sender_name'].first
+      @status = res['status'].first
+      @unsubscribed = res['unsubscribed'].first
+    end
+    
+    def save
+      self.set_info
+    end
+    # Modifies the parameters of a list.  
+    def set_info
+      args = { :list_id => @id, :user_key => @user.user_key }
+      args[:sublist_id] = @sublist_id unless @sublist_id.nil? or @sublist_id == '0'
+      args[:name] = @name unless name.nil? 
+      args[:query] = @query unless @query.nil?
+      args[:language] = @language unless @language.nil?
+      args[:status] = @status unless @status.nil?
+      args[:policy] = @policy unless @policy.nil?
+      args[:sender_name] = @sender_name unless @sender_name.nil?
+      args[:sender_email] = @sender_email unless @sender_email.nil?
+      args[:forward_page] = @forward_page unless @forward_page.nil?
+      args[:goto_oi] = @goto_oi unless @goto_oi.nil?
+      args[:goto_di] = @goto_di unless @goto_di.nil?
+      args[:goto_oo] = @goto_oo unless @goto_oo.nil?
+      res = @user.session.request("CakeMail::API::ClassList", "SetInfo", args)
+    end
+    # Modifies the structure of a list.
+    def edit_structure(action, field, type = nil)
+      args = { :list_id => @id, :user_key => @user.user_key, :action => action, :field => field }
+      args[:type] = type unless type.nil?
+      res = @user.session.request("CakeMail::API::ClassList", "EditStructure", args)
+    end
+    # Returns the fields of the list.
+    def get_fields
+      res = @user.session.request("CakeMail::API::ClassList", "GetFields", { :list_id => @id, :user_key => @user.user_key })
+      res['data']
+    end
+    # Import a list of emails into the list.
+    #
+    # Custom argument :
+    # * record = [ { :data => [ { :type => 'type', :value => 'value' }, { :type => 'type', :value => 'value' }, ... ] }, 
+    #   { :data => [ { :type => 'type', :value => 'value' }, { :type => 'type', :value => 'value' }, ... ] }, ... ]
+    def import(record)
+      res = @user.session.request("CakeMail::API::ClassList", "Import", { :list_id => @id, :record => record, :user_key => @user.user_key })
+      return res['record']
+    end
+    # Displays the list.
+    #
+    # Argument :  
+    # * args = { :status => required, bounce_type => optional, limit => optional, offset => optional, count => optional }
+    def show(args)
+      raise ArgumentError if args.nil? or args[:status].nil?
+      options = { :list_id => @id, :status => args[:status], :user_key => @user.user_key }
+      options[:bounce_type] = args[:bounce_type] unless args[:bounce_type].nil?
+      options[:limit] = args[:limit] unless args[:limit].nil?
+      options[:offset] = args[:offset] unless args[:offset].nil?
+      options[:count] = args[:count] unless args[:count].nil?
+      res = @user.session.request("CakeMail::API::ClassList", "Show", options)
+      if !args[:count].nil?
+        return res['count']
+      end
+      return res['record']
+    end
+    # Searches for one or more records matching a set of conditions. The search is performed using the equivalent of LIKE '%text%' in SQL.
+    def search(args)
+      raise ArgumentError if args.nil? or args[:data].nil?
+      options = { :data => args[:data], :list_id => @id, :user_key => @user.user_key }
+      options[:limit] = args[:limit] unless args[:limit].nil?
+      options[:offset] = args[:offset] unless args[:offset].nil?
+      options[:count] = args[:count] unless args[:count].nil?
+      res = @user.session.request("CakeMail::API::ClassList", "Search", options)
+      if !args[:count].nil?
+        return res['count']
+      end
+      return res['record']
+    end
+    # Subscribes an email into a list. This function, by default, activates the opt-in and douopt-in triggers. Important: before using this
+    # function, the list's policy must be accepted otherwise an error will occur!
+    #
+    # Custom argument:
+    # * data = [ { :type => "last_name, :value => "Doe" }, ... ]
+    def subscribe_email(email, no_triggers = nil, data = nil)
+      args = { :email => email, :list_id => @id, :user_key => @user.user_key }
+      args[:no_triggers] = no_triggers unless no_triggers.nil?
+      args[:data] = data unless data.nil?
+      res = @user.session.request("CakeMail::API::ClassList", "SubscribeEmail", args)
+      return res['record_id']
+    end
+    # Unsubscribes an email from a list. This function activates the opt-out triggers.
+    def unsubscribe_email(email)
+      res = @user.session.request("CakeMail::API::ClassList", "UnsubscribeEmail", { :email => email, :list_id => @id, 
+        :user_key => @user.user_key })
+    end
+    # Deletes an email from a list.  
+    def delete_email(email)
+      res = @user.session.request("CakeMail::API::ClassList", "DeleteEmail", { :email => email, :list_id => @id, 
+        :user_key => @user.user_key })
+    end
+    # Deletes a record from a list using the record's id.  
+    def delete_record(record_id)
+      res = @user.session.request("CakeMail::API::ClassList", "DeleteRecord", { :record_id => record_id, :list_id => @id, 
+        :user_key => @user.user_key })
+    end
+    # Retrieves information for a record from a list.  
+    def get_record(record_id, record_key = nil)
+      args = { :record_id => record_id, :list_id => @id, :user_key => @user.user_key }
+      args[:record_key] = record_key unless record_key.nil?
+      res = @user.session.request("CakeMail::API::ClassList", "GetRecord", args)
+      return { :id => res['id'].first, :status => res['status'].first, :email => res['email'].first, :data => res['data'] }
+    end
+    # Modifies a record into a list.  
+    def update_record(record_id, data, record_key = nil)
+      args = { :data => data, :record_id => record_id, :list_id => @id, :user_key => @user.user_key }
+      args[:record_key] = record_key unless record_key.nil?
+      res = @user.session.request("CakeMail::API::ClassList", "UpdateRecord", args)
+    end
+    # Adds a test email to a list.  
+    def add_test_email(email)
+      res = @user.session.request("CakeMail::API::ClassList", "AddTestEmail", { :email => email, :list_id => @id, 
+        :user_key => @user.user_key })
+    end
+    # Retrieves the test emails for a list.  
+    def get_test_emails
+      res = @user.session.request("CakeMail::API::ClassList", "GetTestEmails", { :list_id => @id, 
+        :user_key => @user.user_key })
+      return res['test_email']
+    end
+    # Deletes a test email of a list.  
+    def delete_test_email(test_email_id)
+      res = @user.session.request("CakeMail::API::ClassList", "DeleteTestEmail", { :test_email_id => test_email_id, :list_id => @id, 
+        :user_key => @user.user_key })
+    end
+    # Creates a sublist from list. It supports up to 5 conditions for creating the sublist. Each condition is defined by a field, a 
+    # function and a value. To connect the conditions between them, a radio option of type AND/OR is used. If the radio option is not 
+    # specified, the OR option will be used by default.
+    #
+    # Custom argument:
+    # * data = [ { :type => "0_field", :value => "email" }, { :type => "0_function", :value => "LIKE" }, 
+    #   { :type => "0_value", :value => "test" }, ... ]
+    def create_sublist(data, sublist_name)
+      res = @user.session.request("CakeMail::API::ClassList", "CreateSublist", { :data => data, :list_id => @id, 
+        :user_key => @user.user_key, :sublist_name => sublist_name })
+      return res['sublist_id']
+    end
+    # Deletes a sublist.  
+    def delete_sublist(sublist_id)
+      res = @user.session.request("CakeMail::API::ClassList", "DeleteSublist", { :sublist_id => sublist_id, 
+        :user_key => @user.user_key })
+    end
+    # Tests a sublist.
+    #
+    # Custom argument:
+    # * data = [ { :type => "0_field", :value => "email" }, { :type => "0_function", :value => "LIKE" }, 
+    #   { :type => "0_value", :value => "test" }, ... ]
+    def test_sublist(data)
+      res = @user.session.request("CakeMail::API::ClassList", "TestSublist", { :data => data, :list_id => @id, 
+        :user_key => @user.user_key })
+      return res['record']
+    end
+    # Retrieves the sublists for a list.  
+    def get_sublists
+      res = @user.session.request("CakeMail::API::ClassList", "GetSublists", { :list_id => @id, 
+        :user_key => @user.user_key })
+      return res['sublist']
+    end
+    
+    class << self
+      # Creates a list.  
+      #
+      # Arguments :
+      # * args = { user => required, :name => required, :sender_name => required, :sender_email, :data => optional/custom }
+      # Custom argument:
+      # * :data => [ { :type => "text", :value => "city" }, { :type => "integer", :value => "age" }, ... ]
+      def create(args)
+        raise ArgumentError if args.nil? or args[:user].nil? or args[:name].nil? or args[:sender_email].nil? or args[:sender_name].nil?
+        options = { :user_key => args[:user].user_key, :name => args[:name], :sender_name => args[:sender_name],
+           :sender_email => args[:sender_email] }
+        options[:data] = args[:data] unless args[:data].empty?
+         res = args[:user].session.request("CakeMail::API::ClassList", "Create", options)
+         List.new(res['id'].first, args[:user])
+      end
+      # Retrieves the list of lists.  
+      #
+      # Arguments :
+      # * args = { user => required, status => optional, :limit => optional, :offset => optional, :count => optional }
+      def get_list(args)
+        raise ArgumentError if args.nil? or args[:user].nil?
+        options = { :user_key => args[:user].user_key }
+        options[:status] = args[:status] unless args[:status].nil?
+        options[:limit] = args[:limit] unless args[:limit].nil?
+        options[:offset] = args[:offset] unless args[:offset].nil?
+        options[:count] = args[:count] unless args[:count].nil?
+        res = args[:user].session.request("CakeMail::API::ClassList", "GetList", options)
+        if !args[:count].nil?
+          return res['count'].first
+        end
+        return res['list']
+      end
+    end
+  end
+end