ruby-cakemail 0.0.1

data/lib/cakemail/template.rb

@@ -0,0 +1,81 @@
+#  Template is HTML or Text based content that may be stored for later use. 
+module CakeMail
+  module API
+    class ClassTemplate < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :name, :user_key ], :optional => [ :type, :message ]
+      method :name => "Delete", :requires => [ :template_id, :user_key ]
+      method :name => "GetList", :requires => [ :user_key ], :optional => [ :type, :limit, :offset, :count ]
+      method :name => "GetInfo", :requires => [ :template_id, :user_key ]
+      method :name => "SetInfo", :requires => [ :template_id, :user_key ], :optional => [ :name, :message, :type ]
+    end
+  end
+
+  class Template
+    attr_reader :id, :client_id
+    attr_accessor :name, :message, :type
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Deletes a template.  
+    def delete
+      @user.session.request("CakeMail::API::ClassTemplate", "Delete", { :template_id => @id, :user_key => @user.user_key })
+      self.freeze
+    end
+    # Returns information about a template.  
+    def get_info(id = @id)
+      res = @user.session.request("CakeMail::API::ClassTemplate", "GetInfo", { :template_id => id, :user_key => @user.user_key })
+      @id = res['id'].first
+      @client_id = res['client_id'].first
+      @name = res['name'].first
+      @type = res['type'].first
+      @message = res['message'].first
+    end
+    
+    def save
+      self.setinfo
+    end
+    # Modifies a template.  
+    def set_info
+      args = { :template_id => @id, :user_key => @user.user_key }
+      args[:name] = @name unless @name.nil?
+      args[:message] = @message unless @message.nil?
+      args[:type] = @type unless @type
+      res = @user.session.request("CakeMail::API::ClassTemplate", "SetInfo", args)
+    end
+    
+    class << self
+      # Creates a new template.  
+      #
+      # Arguments :
+      # * options = { :user => required, :name => required, :type => optional, :message => optional }
+      def create(args)
+        raise ArgumentError if args.nil? or args[:user].nil?
+        options = { :name => name, :user_key => args[:user].user_key }
+        options[:type] = args[:type] unless args[:type].nil?
+        options[:message] = args[:message] unless args[:message].nil?
+         res = args[:user].session.request("CakeMail::API::ClassTemplate", "Create", options)
+         Template.new(res['id'].first, args[:user])
+      end
+      # Retrieves the list of template.  
+      #
+      # Arguments :
+      # * args = { :user => required, :count => optional, :type => 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[:type] = args[:type] 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::ClassTemplate", "GetList", options)
+        if !args[:count].nil?
+          return res['count']
+        end
+        return res['template']
+      end
+    end
+  end
+end

data/lib/cakemail/trigger.rb

@@ -0,0 +1,98 @@
+# A Trigger in an individual email that is sent to a recipient following a specific action. 
+module CakeMail
+  module API
+    class ClassTrigger < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :name, :list_id, :user_key ], :optional => [ :encoding ]
+      method :name => "GetInfo", :requires => [ :trigger_id, :user_key ]
+      method :name => "GetList", :requires => [ :user_key ], :optional => [ :status, :action, :list_id, :parent_id, :limit, :offset, :count ]
+      method :name => "SetInfo", :requires => [ :trigger_id, :user_key ], :optional => [ :status, :encoding, :action, :name,
+          :delay, :parent_id, :send_to, :subject, :sender_name, :sender_email, :html_message, :text_message ]
+    end
+  end
+
+  class Trigger
+    attr_reader :id
+    attr_accessor :status, :encoding, :action, :name, :delay, :parent_id, :send_to, :subject, :sender_name, :sender_email, 
+      :html_message, :text_message
+
+    def initialize(id, user)
+      @user = user
+      @id = id
+      get_info
+    end
+    # Returns information about a trigger.  
+    def get_info(id = @id)
+      res = @user.session.request("CakeMail::API::ClassTrigger", "GetInfo", { :trigger_id => id, :user_key => @user.user_key })
+      @id = res['id'].first
+      @status = res['status'].first
+      @encoding = res['encoding'].first
+      @action = res['action'].first
+      @name = res['name'].first
+      @description = res['description'].first
+      @delay = res['delay'].first
+      @parent_id = res['list_id'].first
+      @send_to = res['send_to'].first
+      @subject = res['subject'].first
+      @sender_name = res['sender_name'].first
+      @sender_email = res['sender_email'].first
+      @html_message = res['html_message'].first
+      @text_message = res['text_message'].first
+    end
+    
+    def save
+      self.setinfo
+    end
+    # Returns information about a trigger.  
+    def set_info
+      args = { :trigger_id => id, :user_key => @user.user_key }
+      args[:status] = status unless status.nil?
+      args[:encoding] = encoding unless encoding.nil?
+      args[:action] = action unless action.nil?
+      args[:name] = name unless name.nil?
+      args[:description] = description unless description.nil?
+      args[:delay] = delay unless delay.nil?
+      args[:parent_id] = parent_id unless parent_id.nil?
+      args[:send_to] = send_to unless send_to.nil?
+      args[:subject] = subject unless subject.nil?
+      args[:sender_name] = sender_name unless sender_name.nil?
+      args[:html_message] = html_message unless html_message.nil?
+      args[:text_message] = text_message unless text_message.nil?
+      res = @user.session.request("CakeMail::API::ClassTrigger", "SetInfo", args)
+    end
+    
+    class << self
+      # Creates a trigger.  
+      #
+      # Arguments :
+      # * args = { :user => required, :name => required, :list_id => required, :encoding => optional, :description => optional }
+      def create(args)
+        raise ArgumentError if args.nil? or args[:user].nil? or args[:name].nil? or args[:list_id]
+        options = { :list_id => args[:list_id], :name => args[:name], :user_key => args[:user].user_key }
+        options[:encoding] = args[:encoding] unless args[:encoding].nil?
+        options[:description] = args[:description] unless args[:description].nil?
+        res = args[:user].session.request("CakeMail::API::ClassTrigger", "Create", options)
+        Trigger.new(res['id'].first, args[:user])
+      end
+      # Retrieves the list of triggers.  
+      #
+      # * args = { :user => required, :status => optional, :action => optional, :list_id => optional, :parent_id => 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[:action] = args[:action] unless args[:action].nil?
+        options[:list_id] = args[:list_id] unless args[:list_id].nil?
+        options[:parent_id] = args[:parent_id] unless args[:parent_id].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::ClassTrigger", "GetList", options)
+        if !args[:count].nil?
+          return res['count'].first
+        end
+        return res['trigger']
+      end
+    end
+  end
+end

data/lib/cakemail/user.rb

@@ -0,0 +1,179 @@
+# A User is an individual associated to a Client. A User has access to a single Account.
+# 
+# Most API calls require the User Key. This key (not to be confused with the Interface Key) can be obtained using the method "Login" by 
+# supplying the user's email and password.
+module CakeMail
+  module API
+    class ClassUser < CakeMail::ServiceClass
+      method :name => "Create", :requires => [ :email, :first_name, :last_name, :password, :password_confirmation, :user_key ], 
+      :optional => [ :language, :mobile_phone, :office_phone, :timezone_id, :title ]
+      method :name => "GetInfo", :requires => [ :user_key ], :optional => [ :user_id ]
+      method :name => "GetList", :requires => [ :status, :user_key ], :optional => [ :count, :limit, :offset ]
+      method :name => "Login", :requires => [ :email, :password ]
+      method :name => "PasswordRecovery", :requires => [ :email, :subject, :text ], :optional => [ :encoding, :headers, :html ]
+      method :name => "SetInfo", :requires => [ :user_id, :user_key ], :optional => [ :email, :password, :password_confirmation, 
+        :status, :first_name, :last_name, :title, :language, :timezone_id, :office_phone, :mobile_phone, :wysiwyg ]
+    end
+  end
+
+  class User
+    attr_reader :user_id, :client_id, :created_on, :timezone, :timezone_id, :last_activity, :groups, :session
+    attr_accessor :email, :first_name, :language, :last_name, :mobile_phone, :office_phone, :password, :status, :title, :user_key, :wysiwyg
+
+    def initialize(session, args)
+      raise ArgumentError if session.nil? or args[:id].nil?
+      @session = session
+      @client_id = args[:client_id].to_i
+      @client_key = args[:client_key]
+      @id = args[:id].to_i
+      @user_key = args[:user_key]
+      get_info
+    end
+    #  Creates a user.  
+    def create(email, password, first_name, last_name, title = nil, language = 'en_US', timezone_id = 152, office_phone = nil, 
+      mobile_phone = nil)
+      args = { :email => email, :password => password, :password_confirmation => password, :first_name => first_name, 
+        :language => language, :last_name => last_name, 
+        :timezone_id => timeezone_id, :user_key => @user_key }
+      args[:title] = title unless title.nil?
+      args[:office_phone] = office_phone unless office_phone.nil?
+      args[:mobile_phone] = mobile_phone unless mobile_phone.nil?
+      res = @session.request("CakeMail::API::ClassUser", "Create", args)
+      user = getinfo(res['user_id'].first.to_i)
+      user.user_key = res['user_key'].first
+      return user
+    end
+    # Retrieves informations about a user.  
+    def get_info(id = @id)
+      res = @session.request("CakeMail::API::ClassUser", "GetInfo", { :user_id => id, :user_key => @user_key })
+      email = res['email'].first
+      password = res['password'].first
+      status = res['status'].first
+      created_on = res['created_on'].first
+      last_activity = res['last_activity'].first
+      first_name = res['first_name'].first
+      last_name = res['last_name'].first
+      title = res['title'].first
+      language = res['language'].first,
+      timezone = res['timezone'].first 
+      timezone_id = res['timezone_id'].first,
+      office_phone = res['office_phone'].first
+      mobile_phone = res['mobile_phone'].first
+      wysiwyg = res['wysiwyg'].first
+      group_ids = res['group_id']
+    end
+    # Returns campaign object.
+    def campaign(id)
+      return CakeMail::Campaign.new(id, self)
+    end
+    # Creates new campaign.
+    def campaign_new(name)
+      return CakeMail::Campaign.create(name, self)
+    end
+    # Returns client object.
+    def client(id)
+      return CakeMail::Client.new(id, self)
+    end
+    # Creates a new client.
+    #
+    # Arguments : 
+    # * args = { :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 client_new(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?
+      args[:user] = self
+      return CakeMail::Client.create(args)
+    end
+    # Returns a list.
+    def list(id)
+      return CakeMail::List.new(id, self)
+    end
+    # Creates a list.
+    #
+    # Arguments :
+    # * args = { :name => required, :sender_name => required, :sender_email, :data => optional/custom }
+    # Custom argument:
+    # * :data => [ { :type => "text", :value => "city" }, { :type => "integer", :value => "age" }, ... ]
+    def list_new(args)
+      raise ArgumentError if args.nil? or args[:name].nil? or args[:sender_email].nil? or args[:sender_name].nil?
+      args[:user] = self
+      return CakeMail::List.create(args)
+    end
+    # Returns a group.
+    def group(id)
+      return CakeMail::Group.new(id, self)
+    end
+    # Creates a new group.
+    def group_new(name, client_id = nil)
+      args = { :user => self, :name => name }
+      args[:client_id] = client_id unless client_id.nil?
+      return CakeMail::Group.create(args)
+    end
+    # Returns a template.
+    def template(id)
+      return CakeMail::Template.new(id, self)
+    end
+    # Creates a new template.
+    #
+    # Arguments :
+    # * options = { :name => required, :type => optional, :message => optional }
+    def template_new(args)
+      args[:user] = self
+      return CakeMail::Template.create(args)
+    end
+    # Returns a trigger.
+    def trigger(id)
+      return CakeMail::Trigger.new(id, self)
+    end
+    # Creates a new trigger
+    #
+    # Arguments :
+    # * args = { :name => required, :list_id => required, :encoding => optional, :description => optional }
+    def trigger_new(args)
+      raise ArgumentError if args.nil? or args[:name].nil? or args[:list_id]
+      args[:user] = self
+      return CakeMail::Trigger.create(args)
+    end
+    
+    def save
+      self.setinfo
+    end
+    # Modifies a user.  
+    def set_info
+      args = { :user_id => @id, :user_key => @user_key }
+      args[:email] = @email unless @email.nil?
+      args[:password] = @password unless @password.nil?
+      args[:password_confirmation] = @password unless @password.nil?
+      args[:status] = @status unless @status.nil?
+      args[:first_name] = @first_name unless @first_name.nil?
+      args[:last_name] = @last_name unless @last_name.nil?
+      args[:title] = @title unless @title.nil?
+      args[:language] = @language unless @language.nil?
+      args[:timezone_id] = @timezone_id unless @timezone_id.nil?
+      args[:office_phone] = @office_phone unless @office_phone.nil?
+      args[:mobile_phone] = @mobile_phone unless @mobile_phone.nil?
+      args[:wysiwyg] = @wysiwyg unless @wysiwyg.nil?
+      @session.request("CakeMail::API::ClassUser", "SetInfo", args )
+    end
+    
+    class << self
+      # Returns a logged in user object.
+      def login(session, email, password)
+        res = session.request("CakeMail::API::ClassUser", "Login", { :email => email, :password => password })
+        User.new(session, { :client_id => res['client_id'].first, :client_key => res['client_key'].first, 
+          :id => res['user_id'].first, :user_key => res['user_key'].first })
+      end
+      # Sends by email the user's password.  
+      def password_recovery(email, subject = "CakeMail Password Recovery", text = "Your password is: ")
+        session.request("CakeMail::API::ClassUser", "PasswordRecovery", { :email => email, :subject => subject, :text => text })
+      end
+    end
+  end
+end

data/lib/crypto/ecb_null_padded_blowfish.rb

@@ -0,0 +1,89 @@
+module Crypt
+  module ECB
+    def padded_last_block(last_block)
+      block = last_block || ''
+      buffer = block.split('')
+      remainingMessageBytes = buffer.length
+      remainingMessageBytes.upto(block_size()-1) { buffer << 0.chr }
+      return buffer.join('')
+    end
+
+    def unpadded_last_block(last_block)
+      block = last_block || ''
+      chars = block.split('')
+      buffer = []
+      chars.each do |c|
+        if c != 0
+          buffer << c
+        else
+          break
+        end
+      end
+      return buffer.join('')
+    end
+
+    def encrypt_stream(plainStream, cryptStream)
+      while ((block = plainStream.read(block_size())) && (block.length == block_size()))
+        cryptStream.write(encrypt_block(block))
+      end
+      cryptStream.write(encrypt_block(padded_last_block(block)))
+    end
+
+    def decrypt_stream(cryptStream, plainStream)
+      while (block = cryptStream.read(block_size()))
+        plainText = decrypt_block(block)
+        plainStream.write(plainText) unless cryptStream.eof?
+      end
+      plainStream.write(unpadded_last_block(plainText))
+    end
+
+    def carefully_open_file(filename, mode)
+      begin
+        aFile = File.new(filename, mode)
+      rescue
+        puts "Sorry. There was a problem opening the file <#{filename}>."
+        aFile.close() unless aFile.nil?
+        raise
+      end
+      return(aFile)
+    end
+
+    def encrypt_file(plainFilename, cryptFilename)
+      plainFile = carefully_open_file(plainFilename, 'rb')
+      cryptFile = carefully_open_file(cryptFilename, 'wb+')
+      encrypt_stream(plainFile, cryptFile)
+      plainFile.close unless plainFile.closed?
+      cryptFile.close unless cryptFile.closed?
+    end
+
+    def decrypt_file(cryptFilename, plainFilename)
+      cryptFile = carefully_open_file(cryptFilename, 'rb')
+      plainFile = carefully_open_file(plainFilename, 'wb+')
+      decrypt_stream(cryptFile, plainFile)
+      cryptFile.close unless cryptFile.closed?
+      plainFile.close unless plainFile.closed?
+    end
+
+    def encrypt_string(plainText)
+      plainStream = StringIO.new(plainText)
+      cryptStream = StringIO.new('')
+      encrypt_stream(plainStream, cryptStream)
+      cryptText = cryptStream.string
+      return(cryptText)
+    end
+
+    def decrypt_string(cryptText)
+      cryptStream = StringIO.new(cryptText)
+      plainStream = StringIO.new('')
+      decrypt_stream(cryptStream, plainStream)
+      plainText = plainStream.string
+      return(plainText)
+    end
+  end
+end
+
+module Crypt
+  class Blowfish
+    include Crypt::ECB
+  end
+end