sugoi-mail 0.1.0 → 0.1.5

data/app/controllers/mailinglist_controller.rb

@@ -1,14 +1,15 @@
 class MailinglistController < ApplicationController
-    verify :only => [ 'show', 'edit', 'destroy' ],
+    verify :only => [ 'show', 'edit', 'remove' ],
         :params => :id,
         :add_flash => { :notice => 'Missing mailinglist ID.' },
         :redirect_to => { :action => 'list' }
 
-    def destroy
+    def remove
+        flash[:notice] = 'The mailing list was successfully destroyed.'
         if request.post?
             Mailinglist.find(params[:id]).destroy
             flash[:notice] = 'The mailinglist was successfully destroyed.'
-            redirect_to :action => 'list'
+            redirect_to :controller => "account", :action => 'welcome'
         else
             flash[:notice] = 'Click Destroy to destroy the mailinglist.'
             redirect_to :action => 'edit', :id => params[:id]
@@ -16,36 +17,89 @@ class MailinglistController < ApplicationController
     end
 
     def edit
+        #session[:mailinglist_id] = params[:id]
         if request.post?
             @mailinglist = Mailinglist.find(params[:id])
             if @mailinglist.update_attributes(params[:mailinglist])
-                if @mailinglist.save
-                    flash[:notice] = 'The mailinglist was successfully edited.'
-                    redirect_to :action => 'show', :id => @mailinglist
-                end
+					@mailinglist.mailinglist_class = MailinglistClass.find_by_id params[:mailinglist_class_id]
+               if @mailinglist.save
+               	flash[:notice] = 'The mailinglist was successfully edited.'
+               	session[:user] = User.find session[:user].id
+               	redirect_to :action => 'show', :id => @mailinglist
+               end
             end
         else
-            @mailinglist = Mailinglist.find(params[:id])
+          @mailinglist = Mailinglist.find(params[:id])
         end
     end
 
     def list
-        @mailinglist_pages, @mailinglists = paginate(:mailinglists)
+        session[:user] = User.find session[:user].id
+        @mailinglists = session[:user].mailinglists
+        # @mailinglist_pages, @mailinglists = paginate(:mailinglists)
     end
 
     def new
+        session[:domain] = Domain.find(session[:domain_id])
         if request.post?
             @mailinglist = Mailinglist.new(params[:mailinglist])
-            if @mailinglist.save
-                flash[:notice] = 'A new mailinglist was successfully added.'
-                redirect_to :action => 'list'
-            end
+				domain = session[:domain]
+				if domain then
+					@mailinglist.user = User.find_by_login_and_domain_id params[:user], domain.id
+					@mailinglist.mailinglist_class = MailinglistClass.find_by_id params[:mailinglist_class_id]
+					if @mailinglist.save
+						flash[:notice] = 'A new mailinglist was successfully added.'
+						session[:user] = User.find session[:user].id
+						redirect_to :action => 'list'
+					end
+				else
+					flash[:notice] = 'Mailinglist could not be added - domain is nil'
+				end
         else
-            @mailinglist = Mailinglist.new
+            #@mailinglist = Mailinglist.new
         end
     end
 
     def show
+        session[:user] = User.find session[:user].id
         @mailinglist = Mailinglist.find(params[:id])
     end
+    
+    def openposting
+    
+    end
+    
+    def new_address
+        
+    end
+    
+    def add_address
+        if request.post?
+            @mailinglist = Mailinglist.find(session[:mailinglist_id])
+				# address = Address.new(params[:address])
+            @mailinglist.subscribe params[:address][:address]
+            session[:user] = User.find session[:user].id
+            redirect_to :action => "show", :id => @mailinglist
+        else
+        end
+    end
+
+	def new_mailinglist_class
+		session[:domain] = Domain.find(session[:domain_id])
+        if request.post?
+            @mailinglist_class = MailinglistClass.new(params[:mailinglist_class])
+				domain = session[:domain]
+				if domain then
+					#@mailinglist.user = User.find_by_login_and_domain_id params[:user], domain.id
+					#@mailinglist.mailinglist_class = MailinglistClass.find_by_id params[:mailinglist_class_id]
+					if @mailinglist_class.save
+						flash[:notice] = 'A new mailinglist class was successfully added.'
+						session[:user] = User.find session[:user].id
+						redirect_to :controller => "account", :action => "welcome"
+					end
+				else
+					flash[:notice] = 'Mailinglist class could not be added - domain is nil'
+				end
+        end
+	end
 end

data/app/controllers/mailservice_controller.rb

@@ -45,20 +45,21 @@ class MailserviceController < ApplicationController
     private
 
     def domain_logged_in?
-        raise "Not logged into domain" unless @session[:domain]
+        raise "Not logged into domain" unless session[:domain_id]
         true
     end
 
     def user_logged_in?
         domain_logged_in?
-        raise "Not logged in as user" unless @session[:user]
+        raise "Not logged in as user" unless session[:user_id]
         true
     end
 
     
     def user_admin? 
         user_logged_in?
-        raise "No privileges to perform that operation" unless @session[:user].domainadmin?
+        raise "No privileges to perform that operation" unless \
+            User.find(session[:user_id]).domainadmin?
         true
     end
 
@@ -68,7 +69,7 @@ class MailserviceController < ApplicationController
         user_logged_in?
         mailinglist = Mailinglist.find_by_id(mailinglist_id)
         raise "Mailing list not found" unless mailinglist
-        unless @session[:user].id == mailinglist.user_id
+        unless session[:user_id] == mailinglist.user_id
             begin
                 user_admin?
             rescue
@@ -97,14 +98,17 @@ class MailserviceController < ApplicationController
     
     # Log into the domain.
     def domain_login domainname, password
-        @session[:domain]=Domain.authenticate domainname, password
+        domain = Domain.authenticate(domainname, password)
+        if domain
+            session[:domain_id]=Domain.authenticate(domainname, password).id
+        end
         domain_logged_in
     end
 
     # Log out of the domain.
     def domain_logout
-        if @session[:domain] then
-           @session[:domain] = nil
+        if session[:domain_id] then
+           session[:domain_id] = nil
            true
         else
             false
@@ -113,16 +117,18 @@ class MailserviceController < ApplicationController
 
     # Verify whether the domain is logged in or not.
     def domain_logged_in
-        not @session[:domain].nil?
+        not session[:domain_id].nil?
     end
 
     # Returns the domain name.
     def domain_name
-        @session[:domain].name
+        Domain.find(session[:domain_id]).name
     end
 
-    # == Administrator methods
-
+    #========================================================================
+    # Administrator methods
+    #========================================================================
+    
     # Returns true if the user is an administrator and false otherwise
     def is_admin
         user_admin? rescue false
@@ -130,23 +136,28 @@ class MailserviceController < ApplicationController
 
     # 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
+    def admin_user_signup login, description, password, password_confirmation, 
+                          mailinglist_admin, domain_admin
         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
+        user.login=login
+        user.domain_id=session[:domain_id]
+        user.password=password
+        user.password_confirmation=password_confirmation
+        user.mailinglistadmin = mailinglist_admin
+        user.domainadmin = domain_admin
+        if user.save then
+            #this is a disgusting hack
+            user.password = password
+            user.password_confirmation = password_confirmation
+            user.save
+            user.mailinglist.description = description
+            user.mailinglist.save
+            return true
         else
-            return false
+            raise user.errors.sort.map { |e| "#{e[0]}: #{e[1]}" }.join("\n")
         end
     end
 
@@ -154,10 +165,17 @@ class MailserviceController < ApplicationController
     def admin_user_list
         user_admin?
 
-        all_users=User.find_all_by_domain_id @session[:domain].id
+        all_users=User.find_all_by_domain_id session[:domain_id]
         return all_users.map { |u| [ u.login, u.description ] }
     end
 
+    # Returns all users in this domain, as a hash
+    def admin_user_collection
+        user_admin?
+        all_users=User.find_all_by_domain_id session[:domain_id]
+        return all_users
+    end
+
     # Resets a user's password.
     def admin_user_reset_password login, password, password_confirmation
         user_admin?
@@ -183,10 +201,13 @@ class MailserviceController < ApplicationController
         if login_confirmation != login then
             raise "Login and login confirmation not the same"
         end
-
+        if User.find(session[:user_id]).login == login then
+            raise "Trying to delete yourself? Very funny"
+        end
+          
         u=User.find_by_login login
         if u then
-            u.destroy
+            User.delete u.id
             return true
         else
             return false
@@ -212,7 +233,7 @@ class MailserviceController < ApplicationController
     def admin_mailinglists_all
         user_admin?
 
-        Mailinglist.find_by_domain(@session[:domain]).map { |ml| ml.id }
+        Mailinglist.find_all_by_domain_id session[:domain_id]
     end
 
     #========================================================================
@@ -223,49 +244,59 @@ class MailserviceController < ApplicationController
     # otherwise false.
     def user_login username, password
         domain_logged_in?
-        @session[:user]=User.authenticate username, password
+
+        session[:user_id] = nil
+
+        user = User.authenticate username, password
+
+        if user
+            session[:user_id]=user.id
+        end
+
         user_logged_in
     end
 
     # Logs the user out.
-    def user_logout; @session[:user] = nil; end
+    def user_logout; session[:user_id] = nil; end
 
     # Returns whether the user is logged in or not.
-    def user_logged_in; not @session[:user].nil?; end
+    def user_logged_in; not session[:user_id].nil?; end
 
     # Returns the user's username.
-    def user_name; @session[:user].login; end
+    def user_name; User.find(session[:user_id]).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 ]
+        Mailinglist.find_all_by_user_id(session[:user_id]) -
+            [ User.find(session[:user_id]).mailinglist ]
     end
 
     # Returns the user's email address.
     def user_email_address
         user_logged_in?
-        @session[:user].address
+        User.find(session[:user_id]).address
     end
 
     # Returns all addresses belonging to this user.
     def user_email_addresses
         user_logged_in?
-        @session[:user].addresses.map { |a| a.address }
+        User.find(session[:user_id]).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 }
+        User.find(session[:user_id]).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 }
+        User.find(session[:user_id]).mailinglist .
+            pending_addresses.map { |a| a.address }
     end
 
     # Allows the user to confirm his email address on the web instead of
@@ -273,7 +304,7 @@ class MailserviceController < ApplicationController
     def user_email_address_confirm(address,code)
         user_logged_in?
         address_obj=Address.find_by_address(address)
-        ml=@session[:user].mailinglist
+        ml=User.find(session[:user_id]).mailinglist
         if ml.confirm(address_obj,code) then 
             ml.save
         else
@@ -284,7 +315,7 @@ class MailserviceController < ApplicationController
     # Lets the user change his password.
     def user_change_password(old_password, password, password_confirmation)
         user_logged_in?
-        user=@session[:user]
+        user=User.find(session[:user_id])
         if User.authenticate(user.login, old_password) then
             user.password=password
             user.password_confirmation=password_confirmation
@@ -306,20 +337,21 @@ class MailserviceController < ApplicationController
     def user_real_name
         user_logged_in?
 
-        @session[:user].description
+        User.find(session[:user_id]).description
     end
 
     # Allows the user to change his real name.
     def user_change_real_name password, new_name
         user_logged_in?
-        user=@session[:user]
+        user=User.find(session[:user_id])
 
         if User.authenticate(user.login, password) then
-            user.description=new_name
-            if user.save
+            ml = user.mailinglist
+            ml.description=new_name
+            if ml.save
                 return new_name
             else
-                errstr = user.errors.sort.map do |fac, err|
+                errstr = ml.errors.sort.map do |fac, err|
                     "#{fac}: #{err}"
                 end.join("\n")
 
@@ -333,16 +365,17 @@ class MailserviceController < ApplicationController
     # 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
+        user = User.find(session[:user_id])
+        if user.mailinglist.subscribe address then
+            user.mailinglist.save
         end
-        @session[:user].mailinglist.addresses
+        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
+        User.find(session[:user_id]).mailinglist.unsubscribe address
     end
 
     # Creates a mailing list of type +mailinglist_class+.  Retrieve the
@@ -356,24 +389,16 @@ class MailserviceController < ApplicationController
         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
+                          :mailinglist_class_id => mailinglist_class_id.id,
+                          :user_id => session[:user_id])
+        m.save
     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 }
+        MailinglistClass.find(:all, :conditions => "id > 1").map { |mlc| mlc.name }
     end
 
     # Returns the attributes of the mailing list class +mlclass+.  Use
@@ -398,7 +423,8 @@ class MailserviceController < ApplicationController
     def mailinglist_find_by_name name
         user_logged_in?
 
-        m=Mailinglist.find_by_address("#{name}@#{@session[:domain].name}")
+        m=Mailinglist.find_by_address \
+            "#{name}@#{Domain.find(session[:domain_id]).name}"
         if m then m[0].id end
     end
 
@@ -408,8 +434,6 @@ class MailserviceController < ApplicationController
 
         if m.destroy
             true
-        else
-            false
         end
     end
 
@@ -435,8 +459,6 @@ class MailserviceController < ApplicationController
     def mailinglist_subscribe mailinglist_id, address
         if my_mailing_list(mailinglist_id).subscribe(address)
             true
-        else
-            false
         end
     end
 
@@ -462,36 +484,36 @@ class MailserviceController < ApplicationController
     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
+
+## TODO: implement message-handling functionality properly
+##     #========================================================================
+##     # Message methods
+##     #========================================================================
+##
+##     # 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
+##     
+##     # 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

data/app/controllers/navigation_controller.rb

@@ -0,0 +1,3 @@
+class NavigationController < ApplicationController
+
+end