repository-manager 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RepositoryManager'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+#
+#require 'rake/testtask'
+#
+#Rake::TestTask.new(:test) do |t|
+#  t.libs << 'lib'
+#  t.libs << 'test'
+#  t.pattern = 'test/**/*_test.rb'
+#  t.verbose = false
+#end
+
+
+#task default: :test

data/app/models/app_file.rb

@@ -0,0 +1,16 @@
+class AppFile < Repository
+
+  mount_uploader :name, RepositoryUploader
+
+  before_save :update_asset_attributes
+
+  private
+
+  def update_asset_attributes
+    if name.present? && name_changed?
+      self.content_type = name.file.content_type
+      self.file_size = name.file.size
+    end
+  end
+
+end

data/app/models/folder.rb

@@ -0,0 +1,7 @@
+class Folder < Repository
+
+  #Add a repository in the folder.
+  def addRepository(repository)
+    repository.update_attribute :parent, self
+  end
+end

data/app/models/repository.rb

@@ -0,0 +1,33 @@
+class Repository < ActiveRecord::Base
+  has_ancestry
+
+  # Associate with the User Classe
+  belongs_to :owner, :polymorphic => true
+  has_many :shares, dependent: :destroy
+  #has_many :items, through: :shares
+
+  scope :files, -> { where type: 'AppFile' }
+  scope :folders, -> { where type: 'Folder' }
+
+  def copy(target_folder)
+    #new_file = self.dup
+    #new_file.folder = target_folder
+    #new_file.save!
+    #
+    #path = "#{Rails.root}/uploads/#{Rails.env}/#{new_file.id}/original"
+    #FileUtils.mkdir_p path
+    #FileUtils.cp_r self.attachment.path, "#{path}/#{new_file.id}"
+    #
+    #new_file
+  end
+
+  # Move the repository into the target_folder
+  # TODO à tester
+  def move(target_folder)
+    if target_folder.type == 'Folder'
+      self.update_attribute :parent, target_folder
+    end
+  end
+
+
+end

data/app/models/share.rb

@@ -0,0 +1,55 @@
+class Share < ActiveRecord::Base
+  has_many :shares_items, dependent: :destroy
+  belongs_to :owner, :polymorphic => true
+  belongs_to :repository
+
+  #scope :recipient, lambda { |recipient|
+  #  joins(:receipts).where('receipts.receiver_id' => recipient.id,'receipts.receiver_type' => recipient.class.base_class.to_s)
+  #}
+  scope :items, lambda { |item|
+    joins(:shares_items).where('shares_items.item_id' => item.id,'shares_items.item_type' => item.class.base_class.to_s)
+  }
+
+  # Return the authorisations of the share for the item
+  def get_authorisations(item)
+    # If the item is the owner, he can do what he want !
+    if self.owner == item
+      return true
+    elsif i = self.shares_items.where(item_id: item.id, item_type: item.class.base_class.to_s).take
+      return {can_add: i.can_add, can_remove: i.can_remove}
+    else
+      return false
+    end
+  end
+
+  # Add items to the share
+  def addItems(items, share_permissions=nil)
+    if items.kind_of?(Array)
+      # Add each item to this share
+      items.each do |i|
+        shareItem = SharesItem.new(share_permissions)
+        shareItem.item = i
+        # Add the shares items in the share
+        self.shares_items << shareItem
+      end
+    else
+      shareItem = SharesItem.new(share_permissions)
+      shareItem.item = items
+      # Add the shares items in the share
+      self.shares_items << shareItem
+    end
+  end
+
+  # Remove items to the share
+  def removeItems(items)
+    if items.kind_of?(Array)
+      # Add each item to this share
+      items.each do |item|
+        self.shares_items.where(item_id: item.id, item_type: item.class.base_class.to_s).take.destroy
+      end
+    else
+      self.shares_items.where(item_id: items.id, item_type: items.class.base_class.to_s).take.destroy
+    end
+  end
+
+end

data/app/models/shares_item.rb

@@ -0,0 +1,9 @@
+class SharesItem < ActiveRecord::Base
+
+  belongs_to :item, polymorphic: true
+  belongs_to :share
+
+  #can_add
+  #can_remove
+  #t.references :shareable, polymorphic: true
+end

data/app/uploaders/repository_uploader.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+class RepositoryUploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or MiniMagick support:
+  # include CarrierWave::RMagick
+  # include CarrierWave::MiniMagick
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  # storage :fog
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # ActionController::Base.helpers.asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process :scale => [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  # Create different versions of your uploaded files:
+  # version :thumb do
+  #   process :scale => [50, 50]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/db/migrate/20131018214212_create_repository_manager.rb

@@ -0,0 +1,40 @@
+class CreateRepositoryManager < ActiveRecord::Migration
+
+  def change
+    #create_table :permissions do |t|
+    #  t.boolean :can_create, :default => false
+    #  t.boolean :can_read, :default => false
+    #  t.boolean :can_update, :default => false
+    #  t.boolean :can_delete, :default => false
+    #  t.boolean :can_share, :default => false
+    #end
+
+    create_table :shares do |t|
+      #t.integer :permission_id
+      #t.integer :user_id
+      t.references :owner, polymorphic: true
+      t.integer :repository_id
+      t.boolean :can_create, :default => false
+      t.boolean :can_read, :default => false
+      t.boolean :can_update, :default => false
+      t.boolean :can_delete, :default => false
+      t.boolean :can_share, :default => false
+    end
+
+    create_table :shares_items do |t|
+      t.integer :share_id
+      #t.integer :item_type
+      #t.integer :item_id
+      t.references :item, polymorphic: true
+      t.boolean :can_add, :default => false
+      t.boolean :can_remove, :default => false
+    end
+
+    create_table :repositories do |t|
+      t.references :owner, polymorphic: true
+      t.string :ancestry
+      t.string :name
+      t.string :type
+    end
+  end
+end

data/db/migrate/20131025085844_add_file_to_repositories.rb

@@ -0,0 +1,8 @@
+class AddFileToRepositories < ActiveRecord::Migration
+  def change
+    #add_column :repositories, :file, :string
+    add_column :repositories, :file_size, :float
+    add_column :repositories, :content_type, :string
+    #add_column :repositories, :repository_type, :string
+  end
+end

data/lib/generators/repository_manager/install_generator.rb

@@ -0,0 +1,30 @@
+module RepositoryManager #:nodoc:
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path("../templates", __FILE__)
+    require 'rails/generators/migration'
+
+    def self.next_migration_number path
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+
+    # all public methods in here will be run in order
+    #def copy_initializer_file
+    #  copy_file "initializer.rb", "config/initializers/repository_manager_initializer.rb"
+    #end
+
+    def copy_migrations
+      migrations = [["20131018214212_create_repository_manager.rb","create_repository_manager.rb"],
+                    ["20131025085844_add_file_to_repositories.rb","add_file_to_repositories.rb"]
+                    ]
+      migrations.each do |migration|
+        migration_template "../../../../db/migrate/" + migration[0], "db/migrate/" + migration[1]
+      end
+    end
+  end
+end

data/lib/generators/repository_manager/templates/initializer.rb

@@ -0,0 +1,4 @@
+Rails.application.configure do
+  # Uncomment this to turn on verbose mode
+  # config.my_gem.verbose = true
+end

data/lib/repository_manager.rb

@@ -0,0 +1,11 @@
+require 'repository_manager/has_repository'
+
+module RepositoryManager
+  module Models
+    #autoload :HasRepository, 'repository_manager/models/has_repository'
+  end
+end
+
+require 'ancestry'
+require 'carrierwave'
+require 'enumerize'

data/lib/repository_manager/has_repository.rb

@@ -0,0 +1,304 @@
+module RepositoryManager
+  module HasRepository
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      def has_repository(options = {})
+
+        has_many :shares, through: :shares_items, dependent: :destroy
+        has_many :shares_items, as: :item, dependent: :destroy
+        has_many :shares_owners, as: :owner, class_name: 'Share'
+
+        # The own repositories
+        has_many :repositories, as: :owner #, dependent: :destroy
+
+        # The repositories shares
+        #if Rails::VERSION::MAJOR == 4
+        #  has_many :shares_repositories, -> { where can_read: true }, as: :item, through: :shares_items, class_name: 'Repository'
+        #else
+          # Rails 3 does it this way
+        has_many :shares_repositories, through: :shares, source: :repository, class_name: 'Repository'
+        #end
+
+        #scope :all_repositories, -> { self.repositories.shares_repositories }
+
+        #All repositories (own and shares)
+        #has_many :all_repositories
+
+        include RepositoryManager::HasRepository::LocalInstanceMethods
+      end
+    end
+
+    module LocalInstanceMethods
+      # Share the repository with the items, with the repo_permissions
+      # repo_permissions contains :
+      #   <tt>:can_read</tt> - Item can download the repository
+      #   <tt>:can_create</tt> - Item can create a new repository on it
+      #   <tt>:can_edit</tt> - Item can edit the repository
+      #   <tt>:can_delete</tt> - Item can delete the repository
+      #   <tt>:can_share</tt> - Item can share the repository
+      # share_permissions contains :
+      #   <tt>:can_add</tt> - Specify if the item can add objects to the share
+      #   <tt>:can_remove</tt> - Specify if the item can remove object to the share
+      def share(repository, items, repo_permissions = nil, share_permissions = nil)
+        authorisations = get_authorisations(repository)
+
+        # Here we look if the instance has the authorisation for making a share
+        if can_share(nil, authorisations)
+
+          repo_permissions = make_repo_permissions(repo_permissions, authorisations)
+
+          share = Share.new(repo_permissions)
+          share.owner = self
+
+          share.addItems(items, share_permissions)
+
+          repository.shares << share
+          repository.save!
+          share
+        else
+          # No permission => No share
+          false
+        end
+      end
+
+      # Create a folder with the name (name) in the directory (sourceFolder)
+      # Returns the object of the folder created if it is ok
+      # Returns false if the folder is not created (no authorisation)
+      def createFolder(name, sourceFolder = nil)
+        # If he want to create a folder in a directory, we have to check if he have the authorisation
+        if can_create(sourceFolder)
+
+          folder = Folder.new(name: name)
+          folder.owner = self
+          folder.save
+
+          # If we want to create a folder in a folder, we have to check if we have the authorisation
+          if sourceFolder
+            sourceFolder.addRepository(folder)
+          end
+
+          return folder
+        else
+          return false
+        end
+      end
+
+      # Delete the repository
+      def deleteRepository(repository)
+        if can_delete(repository)
+          repository.destroy!
+        end
+      end
+
+      # Create the file (file) in the directory (sourceFolder)
+      # Param file can be a File, or a instance of AppFile
+      # Return the object of the file created if it is ok
+      # Return false if the file is not created (no authorisation)
+      def createFile(file, sourceFolder = nil)
+        # If he want to create a file in a directory, we have to check if he have the authorisation
+        if can_create(sourceFolder)
+          if file.class.name == 'File'
+            appFile = AppFile.new
+            appFile.name = file
+            appFile.owner = self
+            appFile.save!
+          elsif file.class.name == 'AppFile'
+            appFile = file
+            appFile.owner = self
+            appFile.save!
+          else
+            return false
+          end
+
+          # Add the file into the sourceFolder
+          if sourceFolder
+            sourceFolder.addRepository(file)
+          end
+
+          return appFile
+        else
+          return false
+        end
+      end
+
+      # Gets the repo authorisations
+      # Return false if the entity has not the authorisation to share this rep
+      # Return true if the entity can share this rep with all the authorisations
+      # Return an Array if the entity can share but with restriction
+      # Return true if the repository is nil (he as all authorisations on his own rep)
+      def get_authorisations(repository=nil)
+        # If repository is nil, he can do what he want
+        return true if repository==nil
+
+        # If the item is the owner, he can do what he want !
+        if repository.owner == self
+          # You can do what ever you want :)
+          return true
+          # Find if a share of this rep exist for the self instance
+        elsif s = self.shares.where(repository_id: repository.id).take
+          # Ok, give an array with the permission of the actual share
+          # (we can't share with more permission then we have)
+          return {can_share: s.can_share, can_read: s.can_read, can_create: s.can_create, can_update: s.can_update, can_delete: s.can_delete}
+        else
+          # We look at the ancestor if there is a share
+          ancestor_ids = repository.ancestor_ids
+          # Check the nearest share if it exist
+          if s = self.shares.where(repository_id: ancestor_ids).last
+            return {can_share: s.can_share, can_read: s.can_read, can_create: s.can_create, can_update: s.can_update, can_delete: s.can_delete}
+          end
+        end
+        # Else, false
+        return false
+      end
+
+      #Return the authorisations of the share (can_add, can_remove)
+      def get_share_authorisations(share)
+        share.get_authorisations(self)
+      end
+
+      # Return true if you can share the repo, else false
+      # You can give the authorisations or the repository as params
+      def can_share(repository, authorisations = nil)
+        can_do('share', repository, authorisations)
+      end
+
+      # Return true if you can read the repo, else false
+      def can_read(repository, authorisations = nil)
+        can_do('read', repository, authorisations)
+      end
+
+      # Return true if you can download the repo, else false
+      # Read = Download for the moment
+      def can_download(repository, authorisations = nil)
+        can_do('read', repository, authorisations)
+      end
+
+      # Return true if you can create in the repo, false else
+      def can_create(repository, authorisations = nil)
+        can_do('create', repository, authorisations)
+      end
+
+      # Return true if you can edit the repo, false else
+      def can_update(repository, authorisations = nil)
+        can_do('update', repository, authorisations)
+      end
+
+      # Return true if you can delete the repo, false else
+      def can_delete(repository, authorisations = nil)
+        can_do('delete', repository, authorisations)
+      end
+
+      # Return true if you can add an item in this share, false else
+      def can_add_to_share(share)
+        can_do_to_share('add', share)
+      end
+
+      # Return true if you can remove an item in this share, false else
+      def can_remove_to_share(share)
+        can_do_to_share('remove', share)
+      end
+
+      # You can here add new items in the share
+      # Param item could be an object or an array of object
+      def addItemsToShare(share, items, share_permissions = nil)
+        authorisations = get_share_authorisations(share)
+        if can_add_to_share(share)
+          share_permissions = make_share_permissions(share_permissions, authorisations)
+          share.addItems(items, share_permissions)
+        end
+      end
+
+      # You can here add new items in the share
+      # Param item could be an object or an array of object
+      def removeItemsToShare(share, items)
+        if can_remove_to_share(share)
+          share.removeItems(items)
+        end
+      end
+
+      private
+
+      # Return if you can do or not this action in the share
+      def can_do_to_share(what, share, authorisations = nil)
+        if authorisations === nil
+          authorisations = share.get_authorisations(self)
+        end
+        case what
+          when 'add'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_add] == true)
+          when 'remove'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_remove] == true)
+        end
+      end
+
+      # Return if you can do or not this action (what)
+      def can_do(what, repository, authorisations = nil)
+        #If we pass no authorisations we have to get it
+        if authorisations === nil
+          authorisations = get_authorisations(repository)
+        end
+
+        case what
+          when 'read'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_read] == true)
+          when 'delete'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_delete] == true)
+          when 'update'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_update] == true)
+          when 'share'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_share] == true)
+          when 'create'
+            authorisations == true || (authorisations.kind_of?(Hash) && authorisations[:can_create] == true)
+          else
+            false
+        end
+
+      end
+
+      # Correct the repo_permissions with the authorisations
+      def make_repo_permissions(wanted_permissions, authorisations)
+        # If it is an array, we have restriction in the permissions
+        if authorisations.kind_of?(Hash) && wanted_permissions
+          # Built the share with the accepted permissions
+          # We remove the permission if we can't share it
+          if wanted_permissions[:can_read] == true && authorisations[:can_read] == false
+            wanted_permissions[:can_read] = false
+          end
+          if wanted_permissions[:can_create] == true && authorisations[:can_create] == false
+            wanted_permissions[:can_create] = false
+          end
+          if wanted_permissions[:can_update] == true && authorisations[:can_update] == false
+            wanted_permissions[:can_update] = false
+          end
+          if wanted_permissions[:can_delete] == true && authorisations[:can_delete] == false
+            wanted_permissions[:can_delete] = false
+          end
+        end
+        return wanted_permissions
+      end
+
+      # Correct the share_permissions with the authorisations
+      def make_share_permissions(wanted_permissions, authorisations)
+        # If it is an array, we have restriction in the permissions
+        if authorisations.kind_of?(Hash) && wanted_permissions
+          # Built the share with the accepted permissions
+          # We remove the permission if we can't share it
+          if wanted_permissions[:can_add] == true && authorisations[:can_add] == false
+            wanted_permissions[:can_add] = false
+          end
+          if wanted_permissions[:can_remove] == true && authorisations[:can_remove] == false
+            wanted_permissions[:can_remove] = false
+          end
+        end
+        return wanted_permissions
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, RepositoryManager::HasRepository