Redmine

class AWSProjectWithRepository < ActionWebService::Struct

  member :id,              :int

  member :identifier,      :string

  member :name,            :string

  member :is_public,       :bool

  member :repository,      Repository

end

  api_method :projects_with_repository_enabled,

             :returns => [[AWSProjectWithRepository]]

             :expects => [:string, :string, :string],

  def projects_with_repository_enabled

    Project.has_module(:repository).find(:all, :include => :repository, :order => 'identifier')

  def repository_created(identifier, vendor, url)

    repository = Repository.factory(vendor, :project => project, :url => url)

  named_scope :has_module, lambda { |mod| { :conditions => ["#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s] } }

  named_scope :builtin, lambda { |*args|

    compare = 'not' if args.first == true

    { :conditions => "#{compare} builtin = 0" }

  }

  serialize :permissions, Array

    perms = perms.collect {|p| p.to_sym unless p.blank? }.compact.uniq if perms

  def add_permission!(*perms)

    self.permissions = [] unless permissions.is_a?(Array)

    permissions_will_change!

    perms.each do |p|

      p = p.to_sym

      permissions << p unless permissions.include?(p)

    end

    save!

  end

  def remove_permission!(*perms)

    return unless permissions.is_a?(Array)

    permissions_will_change!

    perms.each { |p| permissions.delete(p.to_sym) }

    save!

  end

class AddCommitAccessPermission < ActiveRecord::Migration

  def self.up

	Role.find(:all).select { |r| not r.builtin? }.each do |r|

	     r.add_permission!(:commit_access)

  	end

  end

  def self.down

	Role.find(:all).select { |r| not r.builtin? }.each do |r|

	     r.remove_permission!(:commit_access)

  	end

  end

end

                 hashed_password, auth_source_id, permissions

              FROM members, projects, users, roles

                AND roles.id=members.role_id

  while (my ($hashed_password, $auth_source_id, $permissions) = $sth->fetchrow_array) {

      unless ($auth_source_id) {

	  my $method = $r->method;

          if ($hashed_password eq $pass_digest && (defined $read_only_methods{$method} || $permissions =~ /:commit_access/) ) {

          $sthldap->execute($auth_source_id);

#    reposman [OPTIONS...] -s [DIR] -r [HOST]

#     

#  Examples:

#    reposman --svn-dir=/var/svn --redmine-host=redmine.example.net

#    reposman -s /var/svn -r redmine.example.net -u http://svn.example.net

#   -s, --svn-dir=DIR         use DIR as base directory for svn repositories

#   -r, --redmine-host=HOST   assume Redmine is hosted on HOST. Examples:

#                             -r redmine.example.net

#                             -r http://redmine.example.net

#                             -r https://example.net/redmine

#   -o, --owner=OWNER         owner of the repository. using the rails login

#                             allow user to browse the repository within

#                             Redmine even for private project

#   -u, --url=URL             the base url Redmine will use to access your

#                             repositories. This option is used to automatically

#                             register the repositories in Redmine. The project

#                             identifier will be appended to this url. Examples:

#                             -u https://example.net/svn

#                             -u file:///var/svn/

#                             if this option isn't set, reposman won't register

#                             the repositories in Redmine

#   -c, --command=COMMAND     use this command instead of "svnadmin create" to

#                             create a repository. This option can be used to

#                             create non-subversion repositories

#       --scm                 SCM vendor used to register the repository in

#                             Redmine (default: Subversion). Can be one of the

#                             other supported SCM: Bazaar, Darcs, Filesystem,

#                             Git, Mercurial (case sensitive).

#                             This option should be used when both options --url

#                             and --command are used.

#   -f, --force               force repository creation even if the project

#                             repository is already declared in Redmine

#   -t, --test                only show what should be done

#   -h, --help                show help and exit

#   -v, --verbose             verbose

#   -V, --version             print version and exit

#   -q, --quiet               no log

Version = "1.1"

SUPPORTED_SCM = %w( Subversion Darcs Mercurial Bazaar Git Filesystem )

                      ['--command' ,     '-c', GetoptLong::REQUIRED_ARGUMENT],

                      ['--scm',                GetoptLong::REQUIRED_ARGUMENT],

                      ['--force',        '-f', GetoptLong::NO_ARGUMENT],

$command      = "svnadmin create"

$force        = false

$scm          = 'Subversion'

    when '--scm';            $scm          = arg.dup; log("Invalid SCM: #{$scm}", 0, true) unless SUPPORTED_SCM.include?($scm)

    when '--command';        $command =      arg.dup

    when '--force';          $force = true

# Make sure command is overridden if SCM vendor is not Subversion

if $scm != 'Subversion' && $command == 'svnadmin create'

  log("Please use --command option to specify how to create a #{$scm} repository.", 0, true)

end

projects = soap.ProjectsWithRepositoryEnabled

    # if repository is already declared in redmine, we don't create

    # unless user use -f with reposman

    if $force == false and not project.repository.nil?

      log("\trepository for project #{project.identifier} already exists in Redmine", 1)

      next

    end

        command = "#{$command} #{repos_path}"

        raise "#{command} failed" unless system( command  )

      ret = soap.RepositoryCreated project.identifier, $scm, "#{$svn_url}#{project.identifier}"

                                                      :view_changesets,

                                                      :commit_access]

    map.permission :commit_access, {}

  fixtures :projects, :enabled_modules, :repositories

  def test_projects_with_repository_enabled

    result = invoke :projects_with_repository_enabled

    assert_equal EnabledModule.count(:all, :conditions => {:name => 'repository'}), result.size

    project = result.first

    assert project.is_a?(AWSProjectWithRepository)

    assert project.respond_to?(:id)

    assert_equal 1, project.id

    assert project.respond_to?(:identifier)

    assert_equal 'ecookbook', project.identifier

    assert project.respond_to?(:name)

    assert_equal 'eCookbook', project.name

    assert project.respond_to?(:is_public)

    assert project.is_public

    assert project.respond_to?(:repository)

    assert project.repository.is_a?(Repository)

    assert invoke(:repository_created, project.identifier, 'Subversion', 'http://localhost/svn')

    assert project.repository.is_a?(Repository::Subversion)

    assert_equal 'http://localhost/svn', project.repository.url

  def test_add_permission

    role = Role.find(1)

    size = role.permissions.size

    role.add_permission!("apermission", "anotherpermission")

    role.reload

    assert role.permissions.include?(:anotherpermission)

    assert_equal size + 2, role.permissions.size

  end

  def test_remove_permission

    role = Role.find(1)

    size = role.permissions.size

    perm = role.permissions[0..1]

    role.remove_permission!(*perm)

    role.reload

    assert ! role.permissions.include?(perm[0])

    assert_equal size - 2, role.permissions.size

  end