ixtlan-guard 0.7.0 → 0.7.2

data/lib/generators/ixtlan/user_management_controller/USAGE

@@ -1,8 +0,0 @@
-Description:
-    Explain the generator
-
-Example:
-    rails generate guard Thing
-
-    This will create:
-        what/will/it/create

data/lib/generators/ixtlan/user_management_controller/user_management_controller_generator.rb

@@ -1,23 +0,0 @@
-require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
-require 'generators/ixtlan/scaffold/scaffold_generator'
-
-module Ixtlan
-  class UserManagementControllerGenerator < ScaffoldGenerator
-
-    source_root File.expand_path('../../templates', __FILE__)
-
-    class_option :orm, :banner => "NAME", :type => :string, :required => true,
-                         :desc => "ORM to generate the controller for"
-    class_option :gwt, :banner => "PACKAGE_NAME", :type => :string,
-                         :desc => "given gwt package name will generate gwt code"
-
-      
-    def create_controller_files
-        template 'controller.rb', File.join('app/controllers', class_path, "#{controller_file_name}_controller.rb")
-    end
-
-    hook_for :template_engine
-
-  end
-end
-

data/lib/generators/ixtlan/user_management_models/USAGE

@@ -1,8 +0,0 @@
-Description:
-    Explain the generator
-
-Example:
-    rails generate guard Thing
-
-    This will create:
-        what/will/it/create

data/lib/generators/ixtlan/user_management_models/user_management_models_generator.rb

@@ -1,19 +0,0 @@
-module Ixtlan
-  class UserManagementModelsGenerator < Rails::Generators::NamedBase #metagenerator
-    arguments.clear # clear name argument from NamedBase
-    argument :params, :type => :array, :default => ['user'], :required => false, :banner => "user_model [field:type ..] [group_model [field:type ..] [flavor_model1 [field:type ..] flavor_model2 [field:type ..]]]", :desc => "group default: group with field name:string"
-
-    class_option :gwt, :banner => "PACKAGE_NAME", :type => :string,
-                         :desc => "given gwt package name will generate gwt code"
-
-    def name # set alias so NamedBase uses the model as its name
-      @params[0].sub(/\s+.*/, '').singularize
-    end
-    
-    attr_reader :params
-
-    hook_for :orm, :required => true
-
-  end
-end
-

data/lib/generators/ixtlan/user_management_scaffold/user_management_scaffold_generator.rb

@@ -1,13 +0,0 @@
-require 'generators/ixtlan/user_management_models/user_management_models_generator'
-
-module Ixtlan
-  class UserManagementScaffoldGenerator <  UserManagementModelsGenerator #metagenerator
-
-    source_root File.expand_path('../../templates', __FILE__)
-    
-    hook_for :user_management_controller, :default => :user_management_controller
-    hook_for :stylesheets, :in => :rails
-    hook_for :gwt, :type => :boolean, :default => false
-  end
-end
-

data/lib/ixtlan/guard/controllers/maintenance_controller.rb

@@ -1,45 +0,0 @@
-require 'ixtlan/models/maintenance'
-module Ixtlan
-  module Guard
-    module Controllers
-      module MaintenanceController
-        
-        # GET /maintenance
-        # GET /maintenance.xml
-        # GET /maintenance.json
-        def index
-          @maintenance = ::Ixtlan::Guard::Models::Maintenance.new
-          @maintenance.groups = guard.blocked_groups
-          
-          respond_to do |format|
-            format.html # index.html.erb
-            format.xml  { render :xml => @maintenance }
-            format.json  { render :json => @maintenance }
-          end
-        end
-        
-        # PUT /maintenance/block
-        def block
-          guard.block_groups(param[:groups])
-          
-          respond_to do |format|
-            format.html { redirect_to(maintenance_url) }
-            format.xml  { head :ok }
-            format.json  { head :ok }
-          end
-        end
-        
-        # PUT /maintenance/resume
-        def resume
-          guard.block_groups([])
-          
-          respond_to do |format|
-            format.html { redirect_to(maintenance_url) }
-            format.xml  { head :ok }
-            format.json  { head :ok }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ixtlan/guard/controllers/permissions_controller.rb

@@ -1,41 +0,0 @@
-module Ixtlan
-  module Guard
-    module Controllers
-      module PermissionsController
-        
-        # GET /permissions
-        # GET /permissions.xml
-        # GET /permissions.json
-        def index
-          respond_to do |format|
-            format.html
-            format.xml  { render :xml => guard.permissions(self).to_xml }
-            format.json  { render :json => guard.permissions(self).to_json }
-          end
-        end
-        
-        # GET /permissions/1
-        # GET /permissions/1.xml
-        # GET /permissions/1.json
-        def show
-          controller = Object.new
-          def controller.current_user(u = nil)
-            @u = u if u
-            @u
-          end
-          if defined? ::DataMapper
-            controller.current_user(current_user.class.get(params[:id]))
-          else
-            controller.current_user(current_user.class.find(params[:id]))
-          end
-          
-          respond_to do |format|
-            format.html
-            format.xml  { render :xml => guard.permissions(controller).to_xml }
-            format.json  { render :json => guard.permissions(controller).to_json }
-          end
-        end      
-      end
-    end
-  end
-end

data/lib/ixtlan/guard/models/maintenance.rb

@@ -1,55 +0,0 @@
-unless String.respond_to? "plural"
-  class String
-    def plural
-      self + "s"
-    end
-  end
-end
-
-module Ixtlan
-  module SerializableModel
-    def self.included(model)
-      model.send :include, ActiveModel::Serializers::JSON
-      model.send :include, ActiveModel::Serializers::Xml
-    end
-
-    def attributes=(attributes)
-      attributes.each do |k, v|
-        if k == k.plural
-          v = case v
-              when String
-                [v]
-              when Array
-                v
-              when Hash
-                v.values.flatten
-              end
-        end
-        send("#{k}=", v)
-      end
-    end
-    
-    def attributes
-      map = instance_variables.collect do |name|
-        [name[1,1000], send(name[1,1000].to_sym)]
-      end.reject do |x| 
-        x[1] == nil
-      end
-      Hash[map]
-    end
-  end
-end
-
-module Ixtlan
-  module Guard
-    module Models
-      class Maintenance
-
-        include Ixtlan::SerializableModel
-        
-        attr_accessor :groups
-        
-      end
-    end
-  end
-end

data/lib/ixtlan/guard/models/user_update_manager.rb

@@ -1,95 +0,0 @@
-module Ixtlan
-  module Guard
-    module Models
-      class UserUpdateManager
-
-        def initialize(options)
-          @group_model = options[:group_model]
-          @user_id = options[:user_id].to_sym
-          @plural_group_name = options[:plural_group_name].to_sym
-          @group_id = options[:group_id].to_sym
-          @group_ids = "#{options[:group_id]}s"
-        end
-        
-        def update_groups(user, params = [])
-          allowed_ids = user.current_user.all_groups.collect { |g| g.id.to_s }
-          
-          group_ids = params[@group_ids] || []
-          group_ids = intersect(group_ids, allowed_ids)
-          
-          current_ids = user.send(@plural_group_name).collect { |g| g.id.to_s }
-          current_ids = intersect(current_ids, allowed_ids)
-          
-          # add
-          (group_ids - current_ids).each do |gid|
-            user.send(@plural_group_name) << @group_model.find(gid)
-          end
-          
-          #delete
-          (current_ids - group_ids).each do |gid|
-            user.groups.delete(@group_model.find(gid))
-          end
-          
-          user.save
-        end
-        
-        def update(user, params = {}, options = {})
-          raise "no user" unless user
-          user.current_user = params.delete("current_user") || params.delete(:current_user) unless user.current_user
-          raise "'current_user' not set" unless user.current_user
-          
-          flavor_id = options[:flavor_id].to_sym
-          flavor_ids = "#{options[:flavor_id]}s"
-          association_model = options[:association_model]
-          retrieve_flavors_method = options[:flavors_for_group].to_sym
-          
-          allowed_ids = user.current_user.send(retrieve_flavors_method, @group_model.admin_group).collect {|i| i.id }
-          allowed_group_ids = user.current_user.all_groups.collect { |g| g.id.to_s }
-
-          group_ids = params[@group_ids] || []
-          group_ids = intersect(group_ids, allowed_group_ids)
-          group_ids.each do |gid|
-            g = @group_model.find(gid)
-            
-            # calculate intersection of current and allowed
-            current_ids = user.send(retrieve_flavors_method, gid.to_i).collect { |d| d.id }
-            current_ids = intersect(current_ids, allowed_ids)
-            
-            # calculate intersection of target and allowed
-            target_ids = ((params.delete(g.to_name) || {})[flavor_ids] || []).collect { |i| i.to_i }
-            target_ids = intersect(target_ids, allowed_ids)
-            
-            # delete
-            (current_ids - target_ids).each do |id|
-              return false unless association_model.delete_all(["user_id=? and group_id=? and #{flavor_id}=?", user.id, gid, id])
-            end
-            
-            # add
-            (target_ids - current_ids).each do |id|
-              return false unless association_model.create(@user_id => user.id, @group_id => gid, flavor_id => id)
-            end
-          end
-          true
-        end
-        
-        def managed_flavors_for_group(user, group_or_id, options)
-          retrieve_flavors_method = options[:flavors_for_group].to_sym
-          group = @group_model.get(group_or_id)
-          if group.root?
-            []
-          else
-            existing = user.send(retrieve_flavors_method, group)
-            managed = user.send(retrieve_flavors_method, @group_model.admin_group)
-            intersect(managed, existing)
-          end
-        end
-        
-        private
-        
-        def intersect(set1, set2)
-          set1 - (set1 - set2)
-        end
-      end
-    end
-  end
-end

data/lib/ixtlan/guard/spec/user_management_models_spec.rb

@@ -1,193 +0,0 @@
-shared_examples_for 'integration-test' do
-
-  describe "UserManagementModels" do
-
-    before :all do
-      @root = Group.find_by_name(Group::ROOT) || Group.create(:name => Group::ROOT)
-      @admin = Group.find_by_name(Group::ADMIN) || Group.create(:name => Group::ADMIN)
-      @translator = Group.find_by_name("translator") || Group.create(:name => "translator")
-      @superuser = User.find_by_id(1)
-      if @superuser.nil? || @superuser.groups == []
-        @superuser = User.create!
-        @superuser.groups << @root
-        @superuser.save!
-      end
-      @main = Domain.find_by_name('main') || Domain.create(:name => 'main')
-      @sub = Domain.find_by_name('sub') || Domain.create(:name => 'sub')
-      DomainsGroupsUser.delete_all
-      @adminuser = User.new('group_ids' => [@admin.id])
-      @adminuser.current_user = @superuser
-      @adminuser.save
-    end
-
-    describe "root user" do
-      it 'should create user' do
-        @adminuser.id.should_not be_nil
-        @adminuser.groups.should == [@admin]
-        @adminuser.domains_for_group(@admin).should == []
-      end
-
-      it 'should add domain to user via update' do
-        @adminuser.domains_for_group(@admin).member?(@main).should be_false
-        @adminuser.current_user = @superuser
-        @adminuser.update_attributes(Group::ADMIN => { 'domain_ids' => [@main.id.to_s] }, 'group_ids' => [@admin.id.to_s])
-        @adminuser.domains_for_group(@admin).member?(@main).should be_true
-        @adminuser.current_user.should be_nil
-      end
-
-      it 'should raise error when adding a domain without current_user set' do
-        @adminuser.current_user = nil
-        lambda { @adminuser.update_attributes(Group::ADMIN => { 'domain_ids' => [@sub.id.to_s] }, 'group_ids' => [@admin.id.to_s]) }.should raise_error
-        @adminuser.current_user.should be_nil
-      end
-
-      it 'should add new group through update' do
-        @adminuser.groups.member?(@translator).should be_false
-        @adminuser.current_user = @superuser
-        @adminuser.update_attributes('group_ids' => [@translator.id.to_s])
-        @adminuser.groups.member?(@translator).should be_true
-      end
-
-      it 'should raise error when adding new group' do
-        @adminuser.groups.member?(@root).should be_false
-        @adminuser.current_user = nil
-        lambda{ @adminuser.update_attributes('group_ids' => [@translator.id.to_s])}.should raise_error
-        @adminuser.current_user.should be_nil
-      end
-    end
-
-    describe "admin user" do
-
-      before :all do
-        @locales = Group.find_by_name("locales") || Group.create(:name => "locales")
-        @adminuser.current_user = @superuser
-        @adminuser.update_attributes('group_ids' => [@admin.id.to_s, @locales.id.to_s], Group::ADMIN => {"domain_ids" => [@main.id.to_s]})
-        @adminuser.save
-      end
-
-      it 'should create new users' do
-        user = User.new('group_ids' => [@admin.id.to_s])
-        user.current_user = @adminuser
-        user.save.should be_true
-        user.groups.member?(@admin).should be_true
-        user.groups.size.should == 1
-      end
-
-      it 'should not add group via update_attributes which admin does not belong to' do
-        user = User.create({:current_user => @adminuser, 'group_ids' => [@root.id.to_s]})
-        user.id.should_not be_nil
-
-        user.groups.member?(@root).should be_false
-        user.groups.size.should == 0
-      end
-
-      it 'should not add group via update_attributes which admin does not belong to' do
-        user = User.create(:current_user => @adminuser)
-        user.id.should_not be_nil
-
-        user.current_user = @adminuser
-        user.update_attributes('group_ids' => [@root.id.to_s]).should be_true
-
-        user.groups.member?(@root).should be_false
-        user.groups.size.should == 0
-      end
-
-      it 'should be able to delete only groups belonging to admin, leave others alone' do
-        user = User.create(:current_user => @superuser, 'group_ids' => [@translator.id.to_s])
-        user.groups.member?(@translator).should be_true
-
-        user.current_user = @adminuser
-        user.update_attributes('group_ids' => []).should be_true
-
-        user.groups.member?(@translator).should be_true
-        user.groups.size.should == 1
-      end
-
-      it 'should be able to add and delete groups belonging to admin' do
-        user = User.create(:current_user => @superuser, 'group_ids' => [@translator.id.to_s])
-        user.id.should_not be_nil
-        user.groups.member?(@translator).should be_true
-
-        user.current_user = @adminuser
-        user.update_attributes('group_ids' => [@admin.id.to_s, @locales.id.to_s]).should be_true
-
-        user.groups.member?(@translator).should be_true
-        user.groups.size.should == 3
-
-        user.current_user = @adminuser
-        user.update_attributes('group_ids' => [@locales.id.to_s]).should be_true
-
-        user.groups.member?(@locales).should be_true
-        user.groups.member?(@translator).should be_true
-        user.groups.size.should == 2
-      end 
-
-      it 'should create new users with domains' do
-        # first create to have an ID
-        user = User.create(:current_user => @adminuser)
-        user.id.should_not be_nil
-        # then add the domain
-        user.update_attributes(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [@main.id.to_s] })
-
-        user.groups.member?(@admin).should be_true
-        user.groups.size.should == 1
-
-        user.domains_for_group(@admin).member?(@main).should be_true
-        user.domains_for_group(@admin).size.should == 1
-      end
-      
-      it 'should add only domains which belongs to admin' do
-        # first create to have an ID
-        user = User.create(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s])
-        user.id.should_not be_nil
-        # then add the domain
-        user.update_attributes(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [@main.id.to_s, @sub.id.to_s] })
-
-        user.groups.member?(@admin).should be_true
-        user.groups.size.should == 1
-
-        user.domains_for_group(@admin).member?(@main).should be_true
-        user.domains_for_group(@admin).size.should == 1
-      end
-
-      it 'should add only domains belonging to the admin' do
-        # first create to have an ID
-        user = User.create(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s])
-        user.id.should_not be_nil
-        # then add the domain
-        user.update_attributes(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [@main.id.to_s, @sub.id.to_s] })
-
-        user.groups.member?(@admin).should be_true
-        user.groups.size.should == 1
-
-        user.domains_for_group(@admin).member?(@main).should be_true
-        user.domains_for_group(@admin).size.should == 1
-
-        user.update_attributes(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [] })
-        user.domains_for_group(@admin).size.should == 0      
-      end
-
-      it 'should delete only domains belonging to the admin' do
-        # first create to have an ID
-        user = User.create(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s])
-        user.id.should_not be_nil
-        # then add the domain
-        user.update_attributes(:current_user => @superuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [@main.id.to_s, @sub.id.to_s] })
-
-        user.groups.member?(@admin).should be_true
-        user.groups.size.should == 1
-
-        user.domains_for_group(@admin).member?(@main).should be_true
-        user.domains_for_group(@admin).member?(@sub).should be_true
-        user.domains_for_group(@admin).size.should == 2
-
-        user.update_attributes(:current_user => @adminuser, 'group_ids' => [@admin.id.to_s], "admin" => {"domain_ids" => [] })
-
-        user.domains_for_group(@admin).member?(@main).should be_false
-        user.domains_for_group(@admin).member?(@sub).should be_true
-        user.domains_for_group(@admin).size.should == 1      
-      end
-    end
-  end
-end
-