sugoi-mail 0.0.0

data/app/models/message.rb

@@ -0,0 +1,293 @@
+require "date"
+require "gurgitate/mailmessage"
+require "net/smtp"
+require "socket"
+# require "pp"
+
+# The Message class is one of the most important classes in
+# sugoi-mail--mainly because it *does* so much.  But anyway.  Herewith a
+# Model With Some Controller-like Things In It.
+#
+# This is the class that handles what a "message" is, and how it
+# behaves.  It makes considerable use of gurgitate-mail's mail-parsing
+# library, so it might not be a bad idea to familiarize yourself with
+# that if trying to work on this.
+class Message < ActiveRecord::Base
+    belongs_to :mailinglist
+    belongs_to :address
+    acts_as_tree :order => "timestamp"
+    # has_and_belongs_to_many :mailinglists
+
+    class << self
+
+        private
+        def get_or_create_messageid mess
+            unless mess.headers["Message-Id"] 
+                mess.headers["Message-Id"] = "<"+`uuidgen || uuid`.chomp + 
+                    "@" + Socket::gethostbyname("localhost")[0] + ">"
+            end
+            mess.headers["Message-Id"][0].contents
+        end
+
+        def get_or_create_timestamp mess
+            if mess.headers["Date"] then
+                DateTime.parse(mess.headers["Date"][0].contents)
+            else
+                Time.now
+            end
+        end
+
+        def find_parent mess
+            referenced=nil
+            if mess.headers["In-Reply-To"] then
+                referenced=mess.headers["In-Reply-To"][0].contents .
+                    match(/(\<[^>]+\>)/)
+                if referenced then
+                    referenced=referenced[1]
+                else
+                    if mess.headers["References"] then
+                        referenced=mess.headers["References"][0].contents.
+                            split.last
+                    end
+                end
+            end
+            Message.find_by_messageid referenced
+        end
+
+        public
+        # Processes a Gurgitate::Mailmessage object or the text of a
+        # message and creates a new Message object.
+        #
+        # +mess+:: Either a Gurgitate::Mailmessage object (with envelope
+        # information intact), or the text of a mail message (in which
+        # case the envelope information must be supplied)
+        # +recipient+:: The envelope recipient (SMTP's RCPT To:) of the mail
+        # message.
+        # +sender+:: The envelope sender (SMTP's MAIL From:) of the mail
+        # message.
+        def from_message(mess, recipient=nil, sender=nil)
+            # This method is way too long, sorry
+            if Gurgitate::Mailmessage === mess then
+                message = self.new
+                message.messageid     = get_or_create_messageid mess
+                message.timestamp     = get_or_create_timestamp mess
+                addr = Address.find_or_create_by_address mess.from
+                if addr.new_record? then addr.save end
+
+                message.address       = addr
+                message.headers       = mess.headers.to_s
+                message.body          = mess.body.to_s
+                message.parent        = find_parent mess
+                message.envelope_from = mess.from
+                message.envelope_to   = mess.to.map { |t| t.contents }
+
+                message.address.save if message.address.new_record?
+
+                ml, type = Mailinglist.find_by_address(message.envelope_to[0])
+
+                if type == :mail and ml then
+                    message.mailinglist = ml
+                end
+
+                return message
+
+            elsif String === mess then
+                from_message Gurgitate::Mailmessage.new(mess),recipient,sender
+            end
+        end
+
+        alias :parse :from_message
+    end
+
+    private
+
+    # Extracts the bare email addresses from a header, without the extra
+    # commentary like the real names.
+    def pull_out_addresses header
+        if header
+            header.contents.split(/,/).map do |addr|
+                Address.parse(addr)[0]
+            end
+        else
+            [ ]
+        end
+    end
+
+    # Returns the proxified replacement for a header, with regular email
+    # addresses replaced by proxy addresses.
+    def proxify_header header, addr
+        unless Mailinglist.find_by_address addr
+            if proxy_address = Address.proxyaddress(addr)
+                header[0] . contents .  sub( Regexp.new(Regexp.escape(addr) ), 
+                                             proxy_address )
+            end
+        end
+    end
+
+    def proxified_plain_addr header, addr
+        matches = addr.match(/(.*?)#(.*?)@(.*)/)
+        if matches then
+            localpart, destdomain, msgs_domain = matches[1..3]
+            to_address = "#{localpart}@#{destdomain}"
+            if Domain.find_by_name(msgs_domain) then
+                header[0] . contents . 
+                    sub(Regexp.new(Regexp.escape(addr)), to_address)
+            end
+        end
+    end
+    
+    def proxify_mail_to_virtual_users 
+        # special-case closed mail to mailing lists owned by virtual users
+        if mailinglist
+            if mailinglist.closed?
+                if Mailinglist.find_by_address(envelope_to)[0].user.
+                    mailinglist.has_address? envelope_from then
+                    if  mailinglist.user.description then
+                        @mess.headers["From"] = "=?UTF-8?B?" + 
+                            [ mailinglist.user.description ].pack("m").chomp + 
+                            "?= <" + mailinglist.user.address + ">"
+                    else
+                        @mess.headers["From"] = mailinglist.user.address
+                    end
+                # @mess.headers.instance_variable_set("@headers_changed",true)
+                end
+            end
+        end
+    end
+
+    def proxify_proxifiable_mailing_list
+        addr=Address.find_or_create_by_address @mess.from
+        if addr.new_record? then addr.save end
+        
+        if addr.outside? then
+            if mailinglist 
+                if mailinglist.proxify?
+                    if @mess.headers["From"] then
+                        @mess.headers["Reply-To"] = addr.proxified mailinglist
+                    end
+                end
+            end
+        end
+    end
+
+    def proxify_normal_addresses
+        %w{From To Cc}.each do |header_name|
+            if @mess.headers[header_name] then
+                @mess.headers[header_name].map do |header|
+                    pull_out_addresses header
+                end.flatten.each do |addr|
+                    if newhdr = proxify_header(@mess.headers[header_name], addr)
+                        @mess.headers[header_name] = newhdr
+                    end
+
+                    if newhdr = proxified_plain_addr(@mess.headers[header_name],
+                                                     addr)
+                        @mess.headers[header_name] = newhdr
+                    end
+                end
+            end
+        end
+    end
+
+
+    # Rewrites the From:, To: and Cc: headers in the current message
+    # to reflect mail proxy addresses instead of "real" addresses.
+    def proxify_addresses
+        @mess = Gurgitate::Mailmessage.new to_s
+
+        proxify_normal_addresses
+        proxify_mail_to_virtual_users
+        proxify_proxifiable_mailing_list 
+
+        @mess.to_s
+    end
+
+    public
+
+    # Returns the text of the message that would be sent out by the
+    # "deliver" message.  This might have headers rewritten to reflect
+    # mail aliases.
+    def messagetext(smtpdetails={})
+        if smtpdetails.length == 1 and smtpdetails[0].has_key? :custom_message
+            smtpdetails[0][:custom_message]
+        end
+
+        if mailinglist.canonical_address? or mailinglist.closed? then
+            proxify_addresses
+        else
+            to_s
+        end
+    end
+
+    def proxy_deliver(from_address, to_address)
+        text = proxify_addresses
+
+        smtpserver  = "localhost"
+        smtpport    = 25
+
+        Net::SMTP.start(smtpserver, smtpport, "localhost") do |smtp|
+            smtp.send_message text, from_address, to_address
+        end
+    end
+        
+
+    # Delivers a message with the optional parameter hash +smtpdetails+.
+    #
+    # 
+    def deliver(*smtpdetails)
+        if Hash === smtpdetails[0] then
+            smtpdetails = smtpdetails[0]
+        else
+            smtpdetails = {}
+        end
+
+        if mailinglist.closed?
+            if mailinglist.user.mailinglist.has_address? envelope_from or
+               mailinglist.user.address == envelope_from then
+            end
+            unless mailinglist.user.mailinglist.has_address? self.envelope_from
+                return bounce
+            end
+        end
+
+        if mailinglist.confirmation?
+            addresses = mailinglist.confirmed_addresses.map { |a| a.address }
+        else
+            addresses = mailinglist.expand_addresses.map { |a| a.address }
+        end
+
+
+        # Hm, not sure why this is *here* instead of somewhere
+        # else.  Fix later.
+        #
+        # (This should actually be in the database somewhere, I'm thinking.)
+        smtpserver  = "localhost"
+        smtpport    = 25
+
+        if smtpdetails.has_key? :smtpserver then
+            smtpserver = smtpdetails[:smtpserver] 
+        end
+        if smtpdetails.has_key? :smtpport then
+            smtpport = smtpdetails[:smtpport] || 25
+        end
+
+        fromaddress = "#{mailinglist.name}-bounces@#{mailinglist.user.domain.name}"
+        Net::SMTP.start(smtpserver, smtpport, "localhost") do |smtp|
+            # puts "Will send email to #{addresses.inspect}"
+            # puts "Message id is #{id}"
+            smtp.send_message messagetext, fromaddress, addresses
+        end
+    end
+
+    def bounce
+        # TODO
+        nil
+    end
+
+    # Returns the text of the current message
+    def to_s
+        headers.to_s.chomp.chomp+"\n\n"+body.to_s
+    end
+
+    alias responses children # "children" comes from acts_as_tree
+end

data/app/models/proxy_link.rb

@@ -0,0 +1,25 @@
+class ProxyLink < ActiveRecord::Base
+    belongs_to :mailinglist
+    belongs_to :address
+    validates_presence_of :mailinglist
+    validates_presence_of :address
+
+    def proxy_address
+        "#{mailinglist.name}-#{id}@#{mailinglist.domain.name}"
+    end
+
+    def self.real_address(addrstr)
+        matches=addrstr.match(/(.+)-([\d]+)@(.*)/)
+        if matches
+            mlname, proxyid, domainname = matches[1..3]
+            domain=Domain.find_by_name domainname
+            ml=Mailinglist.find_all_by_name(mlname).find do |m|
+                m.domain == domain
+            end
+            pl=self.find(proxyid.to_i)
+            if pl.mailinglist_id == ml.id then
+                return pl.address.address
+            end
+        end
+    end
+end

data/app/models/user.rb

@@ -0,0 +1,150 @@
+
+require 'digest/sha1'
+
+# = The User class
+#
+# This is actually based on the user class that is generated
+# automatically by the Login Generator, but I suspect only software
+# historians need to know that.  The Login Generator is pretty much
+# universally adapted by anyone writing a Rails application that has
+# users, and this one is no different.
+#
+# From the schema, the data elements of the User class (because
+# otherwise, they wouldn't be described anywhere).
+#
+# +domain+::            The Domain that the user belongs to.
+# +login+::             The user's username.  This is also the name used
+#                       for their Sugoi-Mail address.
+# +password+::          A SHA1-encrypted password hash.
+# +mailinglist+::       The user's Mailinglist.  The addresses listed in
+#                       this Mailinglist are the address that any message
+#                       sent to +login@domain+ is then forwarded to.
+# +domainadmin+::       Whether the user is a domain administrator or not.
+#                       This mainly controls the ability to create new
+#                       users.
+# +mailinglistadmin+::  Whether they can create, delete, or modify
+#                       mailing lists.
+#
+# The User's email address is actually provided by the Mailinglist that
+# belongs to the user.  By adding at least one Address to this Mailinglist,
+# you can forward messages sent to user@sugoi-domain to their real email
+# address.  Any message sent from the user's real address via
+# sugoi-domain has that real email address rewritten to be the
+# sugoi-domain address.
+
+class User < ActiveRecord::Base
+
+    #----------------------------------------
+    # First of all, email address stuff
+    #----------------------------------------
+    has_many :mailinglists
+    belongs_to :mailinglist
+    belongs_to :domain
+
+    # The list of addresses that mail sent to the user will be forwarded
+    # to.
+    def addresses; mailinglist.addresses end
+
+    # The mail proxy email address
+    def address; "#{mailinglist.name}@#{domain.name}" end
+    # def address=(addr); addresses[0]=addr end
+
+    # The user's "description"--if the user's a person, this would be
+    # their real name.
+    def description
+        mailinglist.description 
+    end
+
+    # Change the user's description.  (Actually changes the user's
+    # Mailinglist's description.)
+    def description=(new_description)
+        m=mailinglist
+        m.description = new_description
+        m.save
+    end
+
+    # Please change the salt to something else, 
+    # Every application should use a different one 
+    @@salt = 'thuchpog10.?guf'
+    cattr_accessor :salt
+
+    # Authenticate a user. 
+    #
+    # Example:
+    #   @user = User.authenticate('bob', 'bobpass')
+    #
+    def self.authenticate(login, pass)
+        find_first(["login = ? AND password = ?", login, sha1(pass)])
+    end  
+
+
+    validates_uniqueness_of :login, :on => :create, :scope => :domain_id
+
+# XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
+# This really needs to be put *back*, with the proviso that I need to 
+# figure out whether it belongs or not (or whether the mailing list
+# creation should handle it instead, which is likely the case.)
+# XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
+#     validates_each :login, :on => :create do |model, attr, value|
+#         if Mailinglist.find(:first, :conditions => [ "name = ?", value ])
+#             model.errors.add(attr, "Address already exists: #{value}" )
+#         end
+#     end
+
+    validates_confirmation_of :password
+    validates_length_of :login, :within => 2..40
+    validates_length_of :password, :within => 5..40
+    validates_presence_of :login, :password, :password_confirmation, :domain,
+        :on => :create
+
+    def after_create
+        ml=Mailinglist.new
+        ml.name=self.login
+        ml.user_id=self.id
+        ml.mailinglist_class=MailinglistClass.find 1
+        if ml.save then
+            self.mailinglist=ml
+            return true
+        end
+    end
+
+    def before_destroy
+        ml=self.mailinglist
+        if ml
+            ml.destroy
+        end
+        self.mailinglist_id = nil
+    end
+
+    protected
+
+    # Apply SHA1 encryption to the supplied password. 
+    # We will additionally surround the password with a salt 
+    # for additional security. 
+    def self.sha1(pass)
+        Digest::SHA1.hexdigest("#{salt}--#{pass}--")
+    end
+
+    before_create :crypt_password
+
+    # Before saving the record to database we will crypt the password 
+    # using SHA1. 
+    # We never store the actual password in the DB.
+    def crypt_password
+        write_attribute "password", self.class.sha1(password)
+    end
+
+    before_update :crypt_unless_empty
+
+    # If the record is updated we will check if the password is empty.
+    # If its empty we assume that the user didn't want to change his
+    # password and just reset it to the old value.
+    def crypt_unless_empty
+        if password.empty?      
+            user = self.class.find(self.id)
+            self.password = user.password
+        else
+            write_attribute "password", self.class.sha1(password)
+        end        
+    end  
+end

data/app/views/account/login.rhtml

@@ -0,0 +1,22 @@
+<%= start_form_tag :action=> "login" %>
+
+<div title="Account login" id="loginform" class="form">
+    <h3>Please login</h3>
+    
+    <% if @flash['notice'] %>
+      <div id="message"><%= @flash['notice'] %></div>
+    <% end %>
+
+    <label for="user_login">Login:</label><br/>
+    <input type="text" name="user_login" id="user_login" size="30" value=""/><br/>
+
+    <label for="user_password">Password:</label><br/>
+    <input type="password" name="user_password" id="user_password" size="30"/>
+
+    <br/>
+    <input type="submit" name="login" value="Login &#187;" class="primary" />
+
+</div>
+
+<%= end_form_tag %>
+

data/app/views/account/logout.rhtml

@@ -0,0 +1,10 @@
+
+<div class="memo">
+    <h3>Logoff</h3>
+
+    <p>You are now logged out of the system...</p>
+      
+    <%= link_to "&#171; login", :action=>"login"%>  
+      
+</div>
+

data/app/views/account/signup.rhtml

@@ -0,0 +1,17 @@
+<%= start_form_tag :action=> "signup" %>
+
+<div title="Account signup" id="signupform" class="form">
+  <h3>Signup</h3>
+  <%= error_messages_for 'user' %><br/>
+  
+  <label for="user_login">Desired login:</label><br/>
+  <%= text_field "user", "login", :size => 30 %><br/>
+  <label for="user_password">Choose password:</label><br/>
+  <%= password_field "user", "password", :size => 30 %><br/>
+  <label for="user_password_confirmation">Confirm password:</label><br/>
+  <%= password_field "user", "password_confirmation", :size => 30 %><br/>
+
+<input type="submit" value="Signup &#187;" class="primary" />
+
+<%= end_form_tag %>
+

data/app/views/account/welcome.rhtml

@@ -0,0 +1,13 @@
+
+<div class="memo">
+    <h3>Welcome</h3>
+
+    <p>You are now logged into the system...</p>
+    <p>
+    Since you are here it's safe to assume the application never called store_location, otherwise
+    you would have been redirected somewhere else after a successful login.
+    </p>
+      
+    <%= link_to "&#171; logout", :action=>"logout"%>  
+      
+</div>

data/app/views/address/_form.rhtml

@@ -0,0 +1,7 @@
+<%= error_messages_for 'address' %>
+
+<!--[form:address]-->
+<p><label for="address_address">Address</label><br/>
+<%= text_area 'address', 'address'  %></p>
+<!--[eoform:address]-->
+

data/app/views/address/edit.rhtml

@@ -0,0 +1,10 @@
+<h1>Editing address</h1>
+
+<%= start_form_tag :action => 'edit', :id => @address %>
+  <%= render :partial => 'form' %>
+  <%= submit_tag 'Save' %>
+<%= end_form_tag %>
+<%= button_to 'Destroy', { :action => 'destroy', :id => @address }, :confirm => 'Are you sure you want to destroy this address?' %>
+
+<%= link_to 'Show', :action => 'show', :id => @address %> |
+<%= link_to 'Back to list', :action => 'list' %>

data/app/views/address/list.rhtml

@@ -0,0 +1,27 @@
+<h1>Listing addresses</h1>
+
+<table>
+  <tr>
+  <% for column in Address.content_columns %>
+    <th><%= column.human_name %></th>
+  <% end %>
+  </tr>
+  
+<% for address in @addresses %>
+  <tr>
+  <% for column in Address.content_columns %>
+    <td><%=h address.send(column.name) %></td>
+  <% end %>
+    <td><%= link_to 'Show', :action => 'show', :id => address %></td>
+    <td><%= link_to 'Edit', :action => 'edit', :id => address %></td>
+    <td><%= link_to 'Destroy', { :action => 'destroy', :id => address }, :post => true, :confirm => 'Are you sure you want to destroy this address?' %>
+  </tr>
+<% end %>
+</table>
+
+<%= link_to 'Previous page', { :page => @address_pages.current.previous } if @address_pages.current.previous %>
+<%= link_to 'Next page', { :page => @address_pages.current.next } if @address_pages.current.next %> 
+
+<br />
+
+<%= link_to 'New address', :action => 'new' %>

data/app/views/address/new.rhtml

@@ -0,0 +1,8 @@
+<h1>New address</h1>
+
+<%= start_form_tag :action => 'new' %>
+  <%= render :partial => 'form' %>
+  <%= submit_tag 'Save' %>
+<%= end_form_tag %>
+
+<%= link_to 'Back to list', :action => 'list' %>

data/app/views/address/show.rhtml

@@ -0,0 +1,8 @@
+<% for column in Address.content_columns %>
+<p>
+  <b><%= column.human_name %>:</b> <%= h @address.send(column.name) %>
+</p>
+<% end %>
+
+<%= link_to 'Edit', :action => 'edit', :id => @address %> |
+<%= link_to 'Back to list', :action => 'list' %>

data/app/views/domain/login.rhtml

@@ -0,0 +1,22 @@
+<%= start_form_tag :action=> "login" %>
+
+<div title="Account login" id="loginform" class="form">
+    <h3>Please login</h3>
+    
+    <% if @flash['notice'] %>
+      <div id="message"><%= @flash['notice'] %></div>
+    <% end %>
+
+    <label for="user_login">Login:</label><br/>
+    <input type="text" name="user_login" id="user_login" size="30" value=""/><br/>
+
+    <label for="user_password">Password:</label><br/>
+    <input type="password" name="user_password" id="user_password" size="30"/>
+
+    <br/>
+    <input type="submit" name="login" value="Login &#187;" class="primary" />
+
+</div>
+
+<%= end_form_tag %>
+

data/app/views/domain/logout.rhtml

@@ -0,0 +1,10 @@
+
+<div class="memo">
+    <h3>Logoff</h3>
+
+    <p>You are now logged out of the system...</p>
+      
+    <%= link_to "&#171; login", :action=>"login"%>  
+      
+</div>
+

data/app/views/domain/signup.rhtml

@@ -0,0 +1,17 @@
+<%= start_form_tag :action=> "signup" %>
+
+<div title="Account signup" id="signupform" class="form">
+  <h3>Signup</h3>
+  <%= error_messages_for 'domain' %><br/>
+  
+  <label for="domain_name">Desired domain name:</label><br/>
+  <%= text_field "domain", "name", :size => 30 %><br/>
+  <label for="domain_password">Choose password:</label><br/>
+  <%= password_field "domain", "password", :size => 30 %><br/>
+  <label for="domain_password_confirmation">Confirm password:</label><br/>
+  <%= password_field "domain", "password_confirmation", :size => 30 %><br/>
+
+<input type="submit" value="Signup &#187;" class="primary" />
+
+<%= end_form_tag %>
+

data/app/views/domain/welcome.rhtml

@@ -0,0 +1,13 @@
+
+<div class="memo">
+    <h3>Welcome</h3>
+
+    <p>You are now logged into the system...</p>
+    <p>
+    Since you are here it's safe to assume the application never called store_location, otherwise
+    you would have been redirected somewhere else after a successful login.
+    </p>
+      
+    <%= link_to "&#171; logout", :action=>"logout"%>  
+      
+</div>