ixtlan 0.2.4 → 0.3.0

data/lib/ixtlan/controllers/domains_controller.rb

@@ -0,0 +1,99 @@
+module Ixtlan
+  module Controllers
+    module DomainsController
+
+      def self.included(base)
+        base.send(:include, Ixtlan::Controllers::SearchQuery)
+      end
+
+      public
+
+      # GET /domains
+      # GET /domains.xml
+      def index
+        @domains = Domain.all(simple_query(:name))
+
+        respond_to do |format|
+          format.html
+          format.xml  { render :xml => @domains }
+        end
+      end
+
+      # GET /domains/1
+      # GET /domains/1.xml
+      def show
+        @domain = Domain.first_or_get!(params[:id])
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render :xml => @domain }
+        end
+      end
+
+      # GET /domains/new
+      # GET /domains/new.xml
+      def new
+        @domain = Domain.new
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render :xml => @domain }
+        end
+      end
+
+      # GET /domains/1/edit
+      def edit
+        @domain = Domain.first_or_get!(params[:id])
+      end
+
+      # POST /domains
+      # POST /domains.xml
+      def create
+        @domain = Domain.new(params[:domain])
+        @domain.current_user = current_user
+
+        respond_to do |format|
+          if @domain.save
+            flash[:notice] = 'Domain was successfully created.'
+            format.html { redirect_to(domain_url(@domain.id)) }
+            format.xml  { render :xml => @domain, :status => :created, :location => domain_url(@domain.id) + ".xml" }
+          else
+            format.html { render :action => "new" }
+            format.xml  { render :xml => @domain.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /domains/1
+      # PUT /domains/1.xml
+      def update
+        @domain = Domain.first_or_get!(params[:id])
+        @domain.current_user = current_user
+
+        respond_to do |format|
+          if @domain.update(params[:domain]) or not @domain.dirty?
+            flash[:notice] = 'Domain was successfully updated.'
+            format.html { redirect_to(domain_url(@domain.id)) }
+            format.xml  { render :xml => @domain }
+          else
+            format.html { render :action => "edit" }
+            format.xml  { render :xml => @domain.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /domains/1
+      # DELETE /domains/1.xml
+      def destroy
+        @domain = Domain.first_or_get(params[:id])
+        @domain.destroy if @domain
+
+        respond_to do |format|
+          flash[:notice] = 'Domain was successfully deleted.'
+          format.html { redirect_to(domains_url) }
+          format.xml  { head :ok }
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/controllers/groups_controller.rb

@@ -0,0 +1,105 @@
+module Ixtlan
+  module Controllers
+    module GroupsController
+      
+      def self.included(base)
+        base.send(:include, Ixtlan::Controllers::SearchQuery)
+      end
+
+      public
+
+      # GET /groups
+      # GET /groups.xml
+      def index
+        @groups = Group.all(simple_query(:name))
+
+        respond_to do |format|
+          format.html
+          format.xml  { render :xml => @groups }
+        end
+      end
+
+      # GET /groups/1
+      # GET /groups/1.xml
+      def show
+        @group = Group.first_or_get!(params[:id])
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render :xml => @group }
+        end
+      end
+
+      # GET /groups/new
+      # GET /groups/new.xml
+      def new
+        @group = Group.new
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render :xml => @group }
+        end
+      end
+
+      # GET /groups/1/edit
+      def edit
+        @group = Group.first_or_get!(params[:id])
+      end
+
+      # POST /groups
+      # POST /groups.xml
+      def create
+        group = params[:group] || {}
+        group.delete(:locales)
+        group.delete(:domains)
+        @group = Group.new(group)
+        @group.current_user = current_user
+
+        respond_to do |format|
+          if @group.save
+            flash[:notice] = 'Group was successfully created.'
+            format.html { redirect_to(group_url(@group.id)) }
+            format.xml  { render :xml => @group, :status => :created, :location => group_url(@group.id) + ".xml" }
+          else
+            format.html { render :action => "new" }
+            format.xml  { render :xml => @group.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /groups/1
+      # PUT /groups/1.xml
+      def update
+        @group = Group.first_or_get!(params[:id])
+        @group.current_user = current_user
+
+        @group.update_children((params[:group] || {}).delete(:locales), :locale)
+
+        respond_to do |format|
+          if @group.update(params[:group]) or not @group.dirty?
+            flash[:notice] = 'Group was successfully updated.'
+            format.html { redirect_to(group_url(@group.id)) }
+            format.xml  { render :xml => @group }
+          else
+            format.html { render :action => "edit" }
+            format.xml  { render :xml => @group.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /groups/1
+      # DELETE /groups/1.xml
+      def destroy
+        @group = Group.first_or_get(params[:id])
+        @group.current_user = current_user
+        @group.destroy if @group
+
+        respond_to do |format|
+          flash[:notice] = 'Group was successfully deleted.'
+          format.html { redirect_to(groups_url) }
+          format.xml  { head :ok }
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/controllers/locales_controller.rb

@@ -0,0 +1,99 @@
+module Ixtlan
+  module Controllers
+    module LocalesController
+
+      def self.included(base)
+        base.send(:include, Ixtlan::Controllers::SearchQuery)
+      end
+
+      public
+
+      # GET /locales
+      # GET /locales.xml
+      def index
+        @locales = Locale.all(simple_query(:code))
+
+        respond_to do |format|
+          format.html
+          format.xml  { render :xml => @locales }
+        end
+      end
+
+      # GET /locales/1
+      # GET /locales/1.xml
+      def show
+        @locale = Locale.first_or_get!(params[:id])
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render :xml => @locale }
+        end
+      end
+
+      # GET /locales/new
+      # GET /locales/new.xml
+      def new
+        @locale = Locale.new
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render :xml => @locale }
+        end
+      end
+
+      # GET /locales/1/edit
+      def edit
+        @locale = Locale.first_or_get!(params[:id])
+      end
+
+      # POST /locales
+      # POST /locales.xml
+      def create
+        @locale = Locale.new(params[:locale])
+        @locale.current_user = current_user
+
+        respond_to do |format|
+          if @locale.save
+            flash[:notice] = 'Locale was successfully created.'
+            format.html { redirect_to(locale_url(@locale.id)) }
+            format.xml  { render :xml => @locale, :status => :created, :location => locale_url(@locale.id) + ".xml" }
+          else
+            format.html { render :action => "new" }
+            format.xml  { render :xml => @locale.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /locales/1
+      # PUT /locales/1.xml
+      def update
+        @locale = Locale.first_or_get!(params[:id])
+        @locale.current_user = current_user
+
+        respond_to do |format|
+          if @locale.update(params[:locale]) or not @locale.dirty?
+            flash[:notice] = 'Locale was successfully updated.'
+            format.html { redirect_to(locale_url(@locale.id)) }
+            format.xml  { render :xml => @locale }
+          else
+            format.html { render :action => "edit" }
+            format.xml  { render :xml => @locale.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /locales/1
+      # DELETE /locales/1.xml
+      def destroy
+        @locale = Locale.first_or_get(params[:id])
+        @locale.destroy if @locale
+
+        respond_to do |format|
+          flash[:notice] = 'Locale was successfully deleted.'
+          format.html { redirect_to(locales_url) }
+          format.xml  { head :ok }
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/controllers/permissions_controller.rb

@@ -2,6 +2,11 @@ module Ixtlan
   module Controllers
     module PermissionsController
 
+      def self.included(base)
+        # TODO the authenticate should NOT be there, i.e. it leaks too much info
+        base.skip_before_filter :authenticate, :guard
+      end
+
       def index
         render :xml => Ixtlan::Guard.export_xml
       end

data/lib/ixtlan/controllers/phrases_controller.rb

@@ -1,15 +1,19 @@
 module Ixtlan
   module Controllers
     module PhrasesController
-      
+
+      private
+
       LOCALE = Object.full_const_get(::Ixtlan::Models::LOCALE)
       TEXT = Object.full_const_get(::Ixtlan::Models::TEXT)
-      
+
+      public
+
       def index
         version = params[:version]
-        
-        locale = if params[:locale] 
-                   LOCALE.get!(params[:locale]) 
+
+        locale = if params[:locale]
+                   LOCALE.get!(params[:locale])
                  else
                    LOCALE.default
                  end
@@ -31,46 +35,46 @@ module Ixtlan
         render :xml => phrases.to_xml
       end
 
-      
+
       def show
         word = Ixtlan::Models::Word.not_approved(:locale => Locale.default, :code => params[:id]).first
         if word
-          phrase = word_to_phrase(word, :text) 
+          phrase = word_to_phrase(word, :text)
           word = Ixtlan::Models::Word.latest_approved(:locale => Locale.default, :code => params[:id]).first
           merge_word_into_phrase(word, phrase) if word
         else
           word = Ixtlan::Models::Word.latest_approved(:locale => Locale.default, :code => params[:id]).first
-          phrase = word_to_phrase(word, :current_text) 
+          phrase = word_to_phrase(word, :current_text)
         end
         render :xml => phrase.to_xml
       end
 
       def create
         phrase = params[:phrase]
-        
+
         # load the locale and delete the locale parameter array
         locale = LOCALE.get!(phrase.delete(:locale)[:code])
-        
+
         if(TEXT.count(:version => nil, :code => phrase[:code], :locale => locale) == 1)
           logger.warn "precondition failed: " + phrase.inspect
           # mimic created action by just loading it
           render :xml => TEXT.first(:version => nil, :code => phrase[:code], :locale => locale).to_xml, :status => :created
           return
         end
-        
+
         phrase[:text] ||= phrase.delete(:current_text)
-        
+
         @text = TEXT.new(phrase)
         if(TEXT.count(:code => phrase[:code], :locale => locale) == 0)
           approve_it = true
         end
-        
+
         # set the missing attributes
         @text.locale = locale
         @text.current_user = current_user
-        
+
         respond_to do |format|
-          success = @text.save 
+          success = @text.save
           if success && approve_it
             @text.current_user = current_user
             success = @text.approve
@@ -85,19 +89,19 @@ module Ixtlan
           end
         end
       end
-      
+
       def update
         new_text = params[:phrase][:text]
         word = TEXT.not_approved(:locale => Locale.default, :code => params[:id]).first
         if word
-          phrase = word_to_phrase(word, :text) 
+          phrase = word_to_phrase(word, :text)
           word_approved = Ixtlan::Models::Word.latest_approved(:locale => Locale.default, :code => params[:id]).first
           merge_word_into_phrase(word_approved, phrase) if word_approved
         else
           # take the latest approved text for the given code and create a new
           # text without version (!= not_approved text) for the given code
           word = TEXT.latest_approved(:locale => Locale.default, :code => params[:id]).first
-          phrase = word_to_phrase(word, :current_text) 
+          phrase = word_to_phrase(word, :current_text)
           word = TEXT.new(:code => params[:id], :locale => Locale.default)
         end
 
@@ -110,7 +114,7 @@ module Ixtlan
         else
           render :xml => word.errors, :status => :unprocessable_entity
         end
-        
+
       end
 
       def approve
@@ -123,12 +127,12 @@ module Ixtlan
             render :xml => word.errors, :status => :unprocessable_entity
           end
         end
-        
-        # if there was no unapproved word or approval succeeded render 
+
+        # if there was no unapproved word or approval succeeded render
         # the latest approved word
         unless word
           word = Ixtlan::Models::Word.latest_approved(:locale => Locale.default, :code => params[:id]).first
-          phrase = word_to_phrase(word, :current_text) 
+          phrase = word_to_phrase(word, :current_text)
           render :xml => phrase.to_xml, :status => :ok
         end
       end

data/lib/ixtlan/controllers/search_query.rb

@@ -0,0 +1,24 @@
+module Ixtlan
+  module Controllers
+    module SearchQuery
+
+      private 
+
+      def simple_query(search_parameter)
+        args = {}
+        args[:limit] = params[:limit].to_i + 1 if params[:limit]
+        args[:offset] = params[:offset].to_i if params[:offset]
+
+        if login = params[search_parameter]
+          if "false" == params[:fuzzy]
+            args[search_parameter] = login
+          else
+            args[search_parameter.like] = "%" + login.to_s + "%"
+          end
+        end
+        args
+      end
+
+    end
+  end
+end

data/lib/ixtlan/controllers/texts_controller.rb

@@ -2,11 +2,11 @@ module Ixtlan
   module Controllers
     module TextsController
 
+      private
+
       LOCALE = Object.full_const_get(::Ixtlan::Models::LOCALE)
       TEXT = Object.full_const_get(::Ixtlan::Models::TEXT)
-      
-      private
-      
+
       def locale_guard
         # TODO
       end
@@ -44,7 +44,7 @@ module Ixtlan
         @text.current_user = current_user
 
         respond_to do |format|
-          success = @text.save 
+          success = @text.save
           if success && approve_it
             @text.current_user = current_user
             success = @text.approve
@@ -63,7 +63,7 @@ module Ixtlan
       def update
         phrase = params[:phrase]
         phrase[:text] ||= phrase.delete(:current_text)
-        
+
         respond_to do |format|
           if @text.update(phrase)
             flash[:notice] = phrase[:text].nil? ? 'Text was successfully approved.' : 'Text was successfully updated.'

data/lib/ixtlan/controllers/users_controller.rb

@@ -0,0 +1,117 @@
+module Ixtlan
+  module Controllers
+    module UsersController
+
+      include SearchQuery
+
+      private
+
+      USER = Object.full_const_get(::Ixtlan::Models::USER)
+
+      def adjust_params(user_params)
+        lang = user_params.delete(:preferred_language)
+        user_params[:language] = lang.nil? ? nil : lang[:code][0..1]
+        user_params.delete(:groups)
+      end
+
+      public
+
+      # GET /users
+      # GET /users.xml
+      def index
+        @users = USER.all(simple_query(:login))
+
+        respond_to do |format|
+          format.html
+          format.xml  { render :xml => @users }
+        end
+      end
+
+      # GET /users/1
+      # GET /users/1.xml
+      def show
+        @user = USER.first_or_get!(params[:id])
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render :xml => @user }
+        end
+      end
+
+      # GET /users/new
+      # GET /users/new.xml
+      def new
+        @user = USER.new
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render :xml => @user }
+        end
+      end
+
+      # GET /users/1/edit
+      def edit
+        @user = USER.first_or_get!(params[:id])
+      end
+
+      # POST /users
+      # POST /users.xml
+      def create
+        user_params = params[:user]
+        groups = adjust_params(user_params)
+        @user = USER.new(user_params)
+        @user.current_user = current_user
+        @user.reset_password
+        @user.update_all_children(groups)
+
+        respond_to do |format|
+          if @user.save
+            flash[:notice] = 'User was successfully created.'
+            format.html { redirect_to(user_url(@user.id)) }
+            format.xml  { render :xml => @user, :status => :created, :location => user_url(@user.id) + ".xml" }
+
+            Mailer.deliver_password(@user.email, "Configuration.instance.password_sender_email", @user.password)
+          else
+            format.html { render :action => "new" }
+            format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /users/1
+      # PUT /users/1.xml
+      def update
+        @user = USER.first_or_get!(params[:id])
+        @user.current_user = current_user
+        user_params = params[:user]
+        @user.update_all_children(adjust_params(user_params))
+        @user.attributes = user_params
+
+        respond_to do |format|
+          if @user.save() or not @user.dirty?
+            flash[:notice] = 'User was successfully updated.'
+            format.html { redirect_to(user_url(@user.id)) }
+            format.xml  { render :xml => @user }
+          else
+            format.html { render :action => "edit" }
+            format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /users/1
+      # DELETE /users/1.xml
+      def destroy
+        @user = USER.first_or_get(params[:id])
+        # @user.current_user = current_user
+        @user.destroy if @user
+
+        respond_to do |format|
+          flash[:notice] = 'User was successfully deleted.'
+          format.html { redirect_to(users_url) }
+          format.xml  { head :ok }
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/controllers/word_bundles_controller.rb

@@ -2,24 +2,29 @@ module Ixtlan
   module Controllers
     module WordBundlesController
 
-      def show
-        locale = params[:id]
+      def self.included(base)
+        # no guard since everyone needs to load the bundles
+        base.skip_before_filter :guard
+      end
+
+      def index
+        locale = params[:code]
         # TODO load in following order and allow to replace findings in the
         # intermediate result set
         # * DEFAULT not_approved
         # * DEFAULT latest_approved
         # * locale-parent latest_approved
         # * locale latest_approved
-        l = Locale.get!(locale)
-        wordMap = {}
+        l = Locale.first(:code => locale) || Locale.get!(locale)
+        word_bundle = {}
         Ixtlan::Models::Word.not_approved(:locale => Locale.default).each do |word|
-          wordMap[word.code] = word
+          word_bundle[word.code] = word
         end
         Ixtlan::Models::Word.approved(:locale => Locale.default).each do |word|
-          wordMap[word.code] = word
+          word_bundle[word.code] = word
         end
-        
-        render :xml => "<word_bundle><locale>#{locale}</locale><words>" + wordMap.values.collect { |w| w.to_xml }.join + "</words></word_bundle>"
+
+        render :xml => "<word_bundle><locale>#{locale}</locale><words>" + word_bundle.values.collect { |w| w.to_xml }.join + "</words></word_bundle>" 
       end
     end
   end

data/lib/ixtlan/digest.rb

@@ -6,9 +6,9 @@ module Ixtlan
     # @param salt String the salt for the password digester
     # @return the encoded password/salt
     def self.ssha(secret, salt)
-      require 'sha1' 
-      require 'base64' 
-      (salt.empty? ? "{SHA}": "{SSHA}") +  
+      require 'sha1'
+      require 'base64'
+      (salt.empty? ? "{SHA}": "{SSHA}") +
         Base64.encode64(::Digest::SHA1.digest(secret + salt) + salt).gsub(/\n/, '')
     end
   end