sugoi-mail 0.0.0

data/app/controllers/mailservice_controller.rb

@@ -0,0 +1,497 @@
+# = Using sugoi-mail in your own web applications
+#
+# Sugoi-Mail provides a SOAP (and XMLRPC) API to let you embed it into
+# your own web appplication without using its own interface.  (This is
+# handy if, for example, you want to make a Xoops or Drupal module for
+# it.)
+#
+# To use the web service, first you need to have a Domain account on
+# the server.  Let's say that your domain is "example.com" and the
+# password for example.com is "example".
+#
+# You'd start a session with Sugoi-Mail by logging into the domain.  I'm
+# going to use SOAP as my example API, with the assumption that you've
+# already had wsdl2ruby build a client library for you with.  
+# *MAKE SURE THAT COOKIES ARE ENABLED IN YOUR SOAP CLIENT!*
+#
+#   wsdl2ruby --wsdl http://sugoi-mail-server/wsdl --type client
+#
+# This being done, you'd connect like this:
+#
+#  client = MailserviceMailservicePort.new
+#  client.domainLogin "example.com", "example"
+#
+# This is how the web application logs in.  Once the application is
+# logged in, then the user (let's keep the "example" theme going with a
+# username of "example" and a password of "password") can log in:
+#
+#  client.userLogin "example", "password"
+#
+# Once the user's logged in, then your application can call the user_*
+# functions--for example, to retrieve the user's email address, use
+# the UserEmailAddress call:
+#
+#  emailaddress = client.userEmailAddress  # returns "example@example.com"
+# 
+#
+# 
+# If you log in as an "admin" user, then all of the admin_* messages are
+# also available to you.
+class MailserviceController < ApplicationController
+    wsdl_service_name "Mailservice"
+    web_service_api MailserviceApi
+    web_service_scaffold :invoke
+
+    private
+
+    def domain_logged_in?
+        raise "Not logged into domain" unless @session[:domain]
+        true
+    end
+
+    def user_logged_in?
+        domain_logged_in?
+        raise "Not logged in as user" unless @session[:user]
+        true
+    end
+
+    
+    def user_admin? 
+        user_logged_in?
+        raise "No privileges to perform that operation" unless @session[:user].domainadmin?
+        true
+    end
+
+    # Verifies whether a mailing list belongs to the currently-logged-in
+    # user or not.
+    def my_mailing_list (mailinglist_id)
+        user_logged_in?
+        mailinglist = Mailinglist.find_by_id(mailinglist_id)
+        raise "Mailing list not found" unless mailinglist
+        unless @session[:user].id == mailinglist.user_id
+            begin
+                user_admin?
+            rescue
+                raise "Permission denied"
+            end
+        end
+        mailinglist
+    end
+
+    public
+
+    #========================================================================
+    # Server methods
+    #========================================================================
+
+    # Use this to ensure that the SOAP connection is still alive and
+    # responding.  This and domain_logged_in are the only API methods
+    # that don't require any kind of authentication.
+    def ping
+        true
+    end
+
+    #========================================================================
+    # domain methods
+    #========================================================================
+    
+    # Log into the domain.
+    def domain_login domainname, password
+        @session[:domain]=Domain.authenticate domainname, password
+        domain_logged_in
+    end
+
+    # Log out of the domain.
+    def domain_logout
+        if @session[:domain] then
+           @session[:domain] = nil
+           true
+        else
+            false
+        end
+    end
+
+    # Verify whether the domain is logged in or not.
+    def domain_logged_in
+        not @session[:domain].nil?
+    end
+
+    # Returns the domain name.
+    def domain_name
+        @session[:domain].name
+    end
+
+    # == Administrator methods
+
+    # Returns true if the user is an administrator and false otherwise
+    def is_admin
+        user_admin? rescue false
+    end
+
+    # Creates a new user.  NOTE: This method requires that you're
+    # already signed in as an administrator.
+    def admin_user_signup login, password, password_confirmation
+        user_admin?
+
+        user=User.new
+
+        if user then
+            user.login=login
+            user.domain=@session[:domain]
+            user.password=password
+            user.password_confirmation=password_confirmation
+            if user.save then
+                true
+            else
+                raise user.errors.sort.map { |e| "#{e[0]}: #{e[1]}" }.join("\n")
+            end
+        else
+            return false
+        end
+    end
+
+    # Returns all users in this domain.
+    def admin_user_list
+        user_admin?
+
+        all_users=User.find_all_by_domain_id @session[:domain].id
+        return all_users.map { |u| [ u.login, u.description ] }
+    end
+
+    # Resets a user's password.
+    def admin_user_reset_password login, password, password_confirmation
+        user_admin?
+
+        user=User.find_by_login login
+        if user then
+            user.password=password
+            user.password_confirmation=password_confirmation
+            if user.save then
+                true
+            else
+                raise user.errors.sort.map { |e| "#{e[0]}: #{e[1]}" }.join("\n")
+            end
+        else
+            raise "user: user not found"
+        end
+    end
+
+    # Deletes a user.
+    def admin_user_delete login, login_confirmation
+        user_admin?
+
+        if login_confirmation != login then
+            raise "Login and login confirmation not the same"
+        end
+
+        u=User.find_by_login login
+        if u then
+            u.destroy
+            return true
+        else
+            return false
+        end
+    end
+
+    # Returns the confirmation code for a particular combination of
+    # mailing list and address.
+    #
+    # This one should probably resend the confirmation message.
+    def admin_get_confirmation_code mailinglist_name, address
+        user_admin?
+
+        m=Mailinglist.find_by_name(mailinglist_name)
+        a=Address.find_by_address(address)
+        c=Confirmationcode.find(:first,:conditions => [ 
+                'mailinglist_id = ?  and address_id = ?', m.id, a.id 
+            ])
+        return c.code
+    end
+
+    # Returns all mailing lists in this domain.
+    def admin_mailinglists_all
+        user_admin?
+
+        Mailinglist.find_by_domain(@session[:domain]).map { |ml| ml.id }
+    end
+
+    #========================================================================
+    # user methods
+    #========================================================================
+    
+    # Logs the user in.  If the user logs in successfully, returns true,
+    # otherwise false.
+    def user_login username, password
+        domain_logged_in?
+        @session[:user]=User.authenticate username, password
+        user_logged_in
+    end
+
+    # Logs the user out.
+    def user_logout; @session[:user] = nil; end
+
+    # Returns whether the user is logged in or not.
+    def user_logged_in; not @session[:user].nil?; end
+
+    # Returns the user's username.
+    def user_name; @session[:user].login; end
+
+    # Returns all the mailing lists that belong to this user.
+    def user_mailinglists
+        user_logged_in?
+        Mailinglist.find_all_by_user_id(@session[:user].id).map { |m| m.id } -
+            [ @session[:user].mailinglist_id ]
+    end
+
+    # Returns the user's email address.
+    def user_email_address
+        user_logged_in?
+        @session[:user].address
+    end
+
+    # Returns all addresses belonging to this user.
+    def user_email_addresses
+        user_logged_in?
+        @session[:user].addresses.map { |a| a.address }
+    end
+
+    # Returns all _confirmed_ email addresses belonging to this user
+    def user_email_addresses_confirmed
+        user_logged_in?
+        @session[:user].mailinglist.confirmed_addresses.map { |a| a.address }
+    end
+
+    # Returns all yet-to-be-confirmed email addresses belong to this
+    # user.
+    def user_email_addresses_unconfirmed
+        user_logged_in?
+        @session[:user].mailinglist.pending_addresses.map { |a| a.address }
+    end
+
+    # Allows the user to confirm his email address on the web instead of
+    # by email.
+    def user_email_address_confirm(address,code)
+        user_logged_in?
+        address_obj=Address.find_by_address(address)
+        ml=@session[:user].mailinglist
+        if ml.confirm(address_obj,code) then 
+            ml.save
+        else
+            false
+        end
+    end
+
+    # Lets the user change his password.
+    def user_change_password(old_password, password, password_confirmation)
+        user_logged_in?
+        user=@session[:user]
+        if User.authenticate(user.login, old_password) then
+            user.password=password
+            user.password_confirmation=password_confirmation
+            if(user.save)
+                return true
+            else
+                errstr = user.errors.sort.map do |fac,err| 
+                    "#{fac}: #{err}" 
+                end.join("\n")
+
+                raise RuntimeError, errstr
+            end
+        else
+            raise "auth: original password incorrect"
+        end
+    end
+
+    # Returns the user's real name.
+    def user_real_name
+        user_logged_in?
+
+        @session[:user].description
+    end
+
+    # Allows the user to change his real name.
+    def user_change_real_name password, new_name
+        user_logged_in?
+        user=@session[:user]
+
+        if User.authenticate(user.login, password) then
+            user.description=new_name
+            if user.save
+                return new_name
+            else
+                errstr = user.errors.sort.map do |fac, err|
+                    "#{fac}: #{err}"
+                end.join("\n")
+
+                raise RuntimeError, errstr
+            end
+        else
+            raise "auth: password incorrect"
+        end
+    end
+
+    # Adds a new email address to this user.
+    def user_email_addresses_add(address)
+        user_logged_in?
+        if @session[:user].mailinglist.subscribe address then
+            @session[:user].mailinglist.save
+        end
+        @session[:user].mailinglist.addresses
+    end
+
+    # Removes an email address from the user's email address list.
+    def user_email_addresses_remove(address)
+        user_logged_in?
+        @session[:user].mailinglist.unsubscribe address
+    end
+
+    # Creates a mailing list of type +mailinglist_class+.  Retrieve the
+    # list of valid mailing list classes with mailinglist_classes.
+    def mailinglist_create mailinglist_name, mailinglist_class
+        user_logged_in?
+
+        mailinglist_class_id = MailinglistClass.find_by_name mailinglist_class
+        unless mailinglist_class_id
+            raise "Class does not exist (check MailinglistClasses for list)"
+        end
+
+        m=Mailinglist.new(:name => mailinglist_name,
+                          :mailinglist_class_id => mailinglist_class_id,
+                          :user => @session[:user])
+        if m then
+            if m.save then
+                return m.address
+            else
+                nil
+            end
+        else
+            nil
+        end
+    end
+
+    # Returns a list of the names of all the mailing list classes.
+    def mailinglist_classes
+        # the first mailing list class is special (it's reserved for
+        # forwarding addresses).
+        MailinglistClass.find_all("id > 1").map { |mlc| mlc.name }
+    end
+
+    # Returns the attributes of the mailing list class +mlclass+.  Use
+    # mailinglist_classes to retrieve a list of mailing list class
+    # names.
+    def mailinglist_class_get_attributes(mlclass)
+        MailinglistClass.find_by_name mlclass
+    end
+
+    # Returns the name of the mailing list with id +id+
+    def mailinglist_name id
+        my_mailing_list(id).name
+    end
+
+    # Returns the email address of the mailing list with id +id+
+    def mailinglist_address id
+        my_mailing_list(id).address
+    end
+
+    # Returns the id of the mailing list with name +name+.  The converse
+    # of mailinglist_name
+    def mailinglist_find_by_name name
+        user_logged_in?
+
+        m=Mailinglist.find_by_address("#{name}@#{@session[:domain].name}")
+        if m then m[0].id end
+    end
+
+    # Deletes a mailing list if you're allowed to do that.
+    def mailinglist_delete mailinglist_id
+        m=my_mailing_list(mailinglist_id) 
+
+        if m.destroy
+            true
+        else
+            false
+        end
+    end
+
+    # Returns a list of addresses on a mailing list.
+    def mailinglist_subscribers mailinglist_id
+        mailinglist=my_mailing_list(mailinglist_id)
+        mailinglist.confirmed_addresses.each do |addr|
+            addr.address
+        end
+    end
+
+    # Returns a list of non-confirmed addresses on a mailing list.
+    def mailinglist_pending mailinglist_id
+        mailinglist=my_mailing_list(mailinglist_id)
+        mailinglist.pending_addresses.map do |addr|
+            addr.address
+        end
+    end
+
+    # Adds an address to a mailing list.  If the mailing list requires
+    # confirmation, then the confirmation code will be emailed to
+    # +address+.
+    def mailinglist_subscribe mailinglist_id, address
+        if my_mailing_list(mailinglist_id).subscribe(address)
+            true
+        else
+            false
+        end
+    end
+
+    # Confirms a subscription to a mailing list.  Returns false if the
+    # confirmation code was incorrect.
+    def mailinglist_confirm mailinglist_name, address, code
+        addr = Address.find_by_address address
+        mailinglist = Mailinglist.find_by_name mailinglist_name
+
+        return false if addr == nil or mailinglist == nil
+
+        # This redundant-looking if is to ensure that it returns only
+        # "true" or "false", and not a not-true-but-still-evaluated-as-
+        # truth value like a mailing list, or a not-false such as nil.
+        if mailinglist.confirm(addr, code)
+            true
+        else
+            false
+        end
+    end
+
+    # Removes an address from a mailing list.
+    def mailinglist_unsubscribe mailinglist_id, address
+        if my_mailing_list(mailinglist_id).unsubscribe(address)
+            true
+        else
+            false
+        end
+    end
+
+    # Returns the IDs of all the messages messages sent to this mailing
+    # list.
+    #
+    # This should probably do something more useful like return all
+    # new messages since some datestamp or something.
+    def mailinglist_messages mailinglist_id
+        my_mailing_list(mailinglist_id).messages
+    end
+
+    #========================================================================
+    # Message methods
+    #========================================================================
+    
+    # Returns the message with the id +id+.
+    def message message_id
+        readable_message(id)
+    end
+
+    # Return the message that this one's a response to.
+    def message_parent message_id
+        readable_message(id).parent
+    end
+
+    # Returns all responses to this message.
+    def message_responses message_id
+        readable_message(id).children.map { |m| m.id }
+    end
+end

data/app/controllers/sugoi_admin_controller.rb

@@ -0,0 +1,93 @@
+class SugoiAdminController < CommandlineController
+    model :mailinglist
+
+    private
+
+    def get_password
+        password = ask "Password: " do |q| q.echo = false end
+        confirmation = ask "Confirm: " do |q| q.echo = false end
+        
+        return [ password, confirmation ]
+    end
+
+    def format_errors errors
+        errors.map do |facility, text|
+            @messages << "#{facility}: #{text}"
+        end
+    end
+
+    public
+
+    def list_domains
+        @domains = Domain.find_all
+    end
+
+    def list_mailinglists(domain_name)
+        @domain = Domain.find_by_name domain_name
+        @mailinglists = Mailinglist.find :all
+    end
+
+    def list_addresses(mailinglist_address)
+        @mailinglist = Mailinglist.find_by_address(mailinglist_address)
+        if @mailinglist then 
+            @mailinglist=@mailinglist[0]
+            @addresses = @mailinglist.addresses
+        else
+            @addresses = []
+        end
+    end
+
+    def create_domain(domain_name)
+        @message = []
+
+        domain = Domain.find_by_name domain_name
+        if domain == nil then
+            password, confirmation = get_password 
+            domain = Domain.new
+            domain.name = domain_name
+            domain.password = password
+            domain.password_confirmation = confirmation
+            if domain.save then
+                @message = [ "Domain \"#{domain_name}\" created successfully" ]
+            else
+                format_errors domain.errors
+            end
+        else 
+            @message = [ "Domain \"#{domain_name}\" already exists." ]
+        end
+    end
+
+    def create_user domain_name, username, email_address = nil, description = nil
+        domain = Domain.find_by_name domain_name
+        if domain then
+            password, confirmation = get_password
+
+            if email_address == nil then
+                email_address = ask "Address to forward #{username}'s email to: "
+                if email_address == "" then email_address = nil end
+            end
+
+            if description == nil then
+                description = ask "Description for #{username}: "
+                if description == "" then description = nil end
+            end
+
+            user = User.new
+            user.domain = domain
+            user.login = username
+            user.password = password
+            user.password_confirmation = password_confirmation
+            user.description = description
+            if user.save then
+                @message = [ "User \"#{username}@#{domain_name}\" created successfully" ]
+                if email_address then
+                    user.addresses << email_address
+                end
+            else
+                format_errors
+            end
+        else
+            @message = [ "domain: Domain \"#{domain.name}\" doesn't exist." ]
+        end
+    end
+end

data/app/helpers/account_helper.rb

@@ -0,0 +1,2 @@
+module AccountHelper
+end

data/app/helpers/address_helper.rb

@@ -0,0 +1,2 @@
+module AddressHelper
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/app/helpers/domain_helper.rb

@@ -0,0 +1,2 @@
+module DomainHelper
+end

data/app/helpers/mailservice_helper.rb

@@ -0,0 +1,2 @@
+module MailserviceHelper
+end

data/app/helpers/sugoi_admin_helper.rb

@@ -0,0 +1,2 @@
+module SugoiAdminHelper
+end