redmine_crm 0.0.36 → 0.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2ae8872b72b3265c1ae6e6993a8b3e0ca78f920
-  data.tar.gz: c8364d112ed92618726af3ef54b16ffc23090abd
+  metadata.gz: 4b0ba370b2cc56fc7a7573ba6e7fa65f63a739a9
+  data.tar.gz: 2e257839a165ba3ac9a35f1735d25721dd7ab4a6
 SHA512:
-  metadata.gz: 7a623433baaf7d77bf346e0a04e0a0052eeee082d063d13b073b20d487208bf1ac0183d03380b18e109d7ddfbc88405f5c8afde7d05c4b3a2c65241f50ff1b67
-  data.tar.gz: 4004698fa8ee608d219a319142708253de3dc0770bba5d856715ffb9c49d7753c0c41320321bf8a9a6296b87a2767249727d215077487972088a58889b07389c
+  metadata.gz: 8166cb752f502d9b172c30bf781ea30313f2a2fc5b2d37b9eb2a7585f8bd5e169509e6ceeee2703def216331ce00ad391ffc2ddf1571773dd0ba6adea658a45c
+  data.tar.gz: b2763d0e87a531654ce8fb73937becf3ddb1fb53a5702452c8ce83bcdfc7172a95a16e429e26192d8e2fff00cb97dd3ac8fdd95ec68c5752418090e7064e67ed

data/.gitignore

@@ -4,6 +4,8 @@
 /_yardoc/
 /coverage/
 /pkg/
+/public/
+/test/public/
 /spec/reports/
 /tmp/
 *.bundle

data/README.md

@@ -1,71 +1,198 @@
 # RedmineCrm
 
-Gem include next functional for Redmine plugins:
-  * rcrm_acts_as_taggable
-  * rcrm_acts_as_votable
-  * rcrm_acts_as_viewable
+This gem is used at RedmineUP as a general place for shared functionality and
+assets. It contains **Chart.js** and **select2** JS libraries, various mixins
+for ActiveRecord models and other things you might find useful.
 
-## Installation
+Among mixins there are:
+
+* rcrm_acts_as_draftable
+* rcrm_acts_as_taggable
+* rcrm_acts_as_viewable
+* rcrm_acts_as_votable
 
-Add this line to your application's Gemfile:
 
+## Installation
+
+Add it to your plugin's Gemfile:
 ```ruby
-gem "redmine_crm"
+gem 'redmine_crm'
+```
+
+Then invoke the following command in your plugin's or Redmine directory:
+```
+$ bundle install
 ```
 
-And then execute:
+And now you can start using it.
 
-    $ bundle
 
-Or install it yourself as:
+## Usage
+### Drafts
+This module allows saving and restoring drafts for different models. To be
+saved as a draft, an instance does not need to pass the validations. Drafts
+store not only model attributes, but also associations and virtual attributes.
+A draft could be linked to a given user, so every user can manage his/her own
+drafts independent of others. A draft might have a parent instance.
+
+First of all, drafts need to be saved somewhere, so let's create a migration:
+```ruby
+class CreateDrafts < Rails.version > '5' ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
+  def change
+    ActiveRecord::Base.create_drafts_table
+  end
+end
+```
+
+Then in the Redmine directory run:
+```
+$ rake redmine:plugins:migrate
+```
 
-    $ gem install redmine_crm
+Next, add `rcrm_acts_as_draftable` to a model for which you want to save drafts:
+```ruby
+class Message < ActiveRecord::Base
+  rcrm_acts_as_draftable
+end
+```
 
-Create migration with next code:
+And that's it for the preparation, now you're ready to make use of drafts:
 ```ruby
-  require 'redmine_crm/rcrm_acts_as_taggable'
+# You can save message as a draft.
+Message.new(subject: 'foo').save_draft
+
+# And later restore message from the draft.
+draft = Message.drafts(nil).last
+message = draft.restore
+puts message.subject
+# => foo
+
+# Draft can be overwritten.
+message.content = 'bar'
+puts message.save_draft
+# => true
+
+# You can also save draft linked to a particular user.
+Message.new(subject: 'baz').save_draft(current_user)
+
+# And restore message from some user's draft.
+user_draft = Message.drafts(current_user).last
+user_message = user_draft.restore
+puts user_message.subject
+# => baz
+
+# It's also possible to restore a bunch of messages at once.
+messages = Message.drafts(current_user).restore_all
+p messages.map(&:subject)
+# => ["baz"]
+
+# When a model instance is saved, corresponding draft is removed.
+puts Message.drafts(current_user).count
+# => 1
+user_message.board_id = Board.first.id
+user_message.save!
+puts Message.drafts(current_user).count
+# => 0
+
+# Draft won't be saved for a persisted instance.
+puts user_message.save_draft
+# => false
+```
 
-  def self.up
-    ActiveRecord::Base.create_taggable_table
-  end
+### Tags
+This module makes it possible to tag objects.
 
-  def self.down
-    ActiveRecord::Base.drop_taggable_table
+First, create a migration:
+```ruby
+class CreateTags < Rails.version > '5' ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
+  def change
+    ActiveRecord::Base.create_taggable_table
   end
 end
 ```
-For rcrm_acts_as_viewed You may add column for your model
-with help:
 
+Then in the Redmine directory run:
+```
+$ rake redmine:plugins:migrate
+```
+
+Next, add `rcrm_acts_as_taggable` to a model for which you want to provide tags:
 ```ruby
+class Contact < ActiveRecord::Base
+  rcrm_acts_as_taggable
+end
+```
 
-YourModel.add_viewings_columns
+TODO: Add examples of usage.
 
-```
-It will add two column to your table (views and total_views) 
-and view_count will return two number: total view and unique views.
-Without this migration you will get only unique views.
+### Viewings
+This module allows you to count views for some ActiveRecord model instances.
 
-Run migration for plugin:
+To count views you'll need to create a migration:
+```ruby
+class CreateViewings < Rails.version > '5' ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
+  def change
+    ActiveRecord::Base.create_viewings_table
+  end
+end
+```
 
+To apply it, run the following in the Redmine directory:
 ```
-rake redmine:plugins:migrate
+$ rake redmine:plugins:migrate
 ```
 
-## Usage
+Then add `rcrm_acts_as_viewed` to a model for which you want to count views.
+```ruby
+class Question < ActiveRecord::Base
+  rcrm_acts_as_viewed
+end
+```
+
+TODO: Provide some usage examples.
 
-Add to model
+### Votes
+With this module you can make your models votable and allow users to vote.
 
+As always, create a migration first:
 ```ruby
-  rcrm_acts_as_taggable
+class CreateVotes < Rails.version > '5' ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
+  def change
+    ActiveRecord::Base.create_votable_table
+  end
+end
+```
+
+Then apply it by running the following command in the Redmine directory:
+```
+$ rake redmine:plugins:migrate
+```
+
+To make a model votable, add `rcrm_acts_as_votable` to it:
+```ruby
+class Question < ActiveRecord::Base
   rcrm_acts_as_votable
+end
 ```
 
+TODO: Write about `rcrm_acts_as_voter` and add usage examples.
 
-## Run test
 
+## Development
+
+If you're planning to extend this gem, you will need to install development
+dependencies. To do this, execute the following command in the project's
+directory:
+```
+$ bundle install
+```
+
+After that you'll be able to run tests:
 ```
-  rake test
+$ bundle exec rake test
 ```
 
-For test for mysql set enviroment variable DB to value 'mysql' and run test.
+SQLite in-memory database will be used by default, which is the fastest way to run tests. To run them using different database adapters, set `DB` environment variable to one of the available values — `mysql`, `postgresql`, `sqlite`. For example, to use PostgreSQL, invoke tests like so:
+```
+$ bundle exec rake test DB=postgresql
+```

data/Rakefile

@@ -1,20 +1,11 @@
-require "bundler/gem_tasks"
-
-require 'rake'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
-# require 'rake/rdoctask'
 
-desc 'Default: run unit tests.'
-task :default => :test
+task default: :test
 
-desc 'Test the acts_as_taggable_on_steroids plugin.'
+desc 'Run tests'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
 end
-
-desc 'Copy migration file to db/migration of plugin'
-file 'copy_migration' do
-  cp "generators/redmine_crm_migration/templates/migration.rb", "db/migrate/redmine_crm.rb"
-end

data/bitbucket-pipelines.yml

@@ -8,10 +8,24 @@ image: ruby:2.3.0
 pipelines:
   default:
     - step:
-        script: # Modify the commands below to build your repository.
-          - bundler --version
+        script:
           - bundle install
-          - gem install byebug
-          - gem install rails -v 5.1.2
-          - gem install sqlite3
-          - rake test
+          - bundle exec rake test DB=sqlite
+          - bundle exec rake test DB=postgresql
+          - bundle exec rake test DB=mysql
+        services:
+          - mysql
+          - postgres
+
+definitions:
+  services:
+    mysql:
+      image: mysql
+      environment:
+        MYSQL_DATABASE: redmine_crm_test
+        MYSQL_ROOT_PASSWORD: password
+    postgres:
+      image: postgres
+      environment:
+        POSTGRES_DB: redmine_crm_test
+        POSTGRES_PASSWORD: password

data/doc/CHANGELOG

@@ -4,6 +4,11 @@ Redmine crm gem - general functions for plugins (tags, vote, viewing, currency)
 Copyright (C) 2011-2018 RedmineUP
 https://www.redmineup.com/
 
+== 2018-03-28 v0.0.37
+
+* Added rcrm_acts_as_draftable
+* Added transform_to_select2 helper 
+
 == 2018-03-22 v0.0.36
 
 * select2_tag improvements

data/lib/redmine_crm.rb

@@ -1,3 +1,6 @@
+require 'active_record'
+require 'action_view'
+
 require 'redmine_crm/version'
 
 require 'redmine_crm/acts_as_list/list'
@@ -10,6 +13,8 @@ require 'redmine_crm/acts_as_votable/rcrm_acts_as_votable'
 require 'redmine_crm/acts_as_votable/rcrm_acts_as_voter'
 require 'redmine_crm/acts_as_votable/vote'
 require 'redmine_crm/acts_as_votable/voter'
+require 'redmine_crm/acts_as_draftable/rcrm_acts_as_draftable'
+require 'redmine_crm/acts_as_draftable/draft'
 
 require 'redmine_crm/currency'
 require 'redmine_crm/helpers/tags_helper'

data/lib/redmine_crm/acts_as_draftable/draft.rb

@@ -0,0 +1,40 @@
+# The MIT License (MIT)
+
+# Copyright (c) 2016-2018 Georg Ledermann
+
+# 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.
+
+module RedmineCrm
+  module ActsAsDraftable
+    class Draft < ActiveRecord::Base
+      belongs_to :user
+      belongs_to :parent, polymorphic: true
+
+      validates_presence_of :data, :target_type
+
+      def restore
+        target_type.constantize.from_draft(self)
+      end
+
+      def self.restore_all
+        find_each.map(&:restore)
+      end
+    end
+  end
+end

data/lib/redmine_crm/acts_as_draftable/rcrm_acts_as_draftable.rb

@@ -0,0 +1,154 @@
+# The MIT License (MIT)
+
+# Copyright (c) 2016-2018 Georg Ledermann
+
+# 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.
+
+module RedmineCrm
+  module ActsAsDraftable #:nodoc: all
+    module Base
+      ALLOWED_DRAFT_OPTIONS = [:parent]
+
+      def draftable?
+        false
+      end
+
+      def rcrm_acts_as_draftable(options = {})
+        raise ArgumentError unless options.is_a?(Hash)
+        raise ArgumentError unless options.keys.all? { |k| ALLOWED_DRAFT_OPTIONS.include?(k) }
+
+        class_attribute :draft_parent
+
+        if options[:parent]
+          parent_class = self.reflect_on_all_associations(:belongs_to).find { |a| a.name == options[:parent] }.try(:klass)
+          raise ArgumentError unless parent_class
+
+          unless parent_class.method_defined?(:drafts)
+            parent_class.class_eval do
+              def drafts(user)
+                Draft.where(user: user, parent: self)
+              end
+
+              def self.child_drafts(user)
+                Draft.where(user: user, parent_type: self.base_class.name)
+              end
+            end
+          end
+
+          self.draft_parent = options[:parent]
+        end
+
+        attr_accessor :draft_id
+        after_create :clear_draft
+
+        extend RedmineCrm::ActsAsDraftable::ClassMethods
+        include RedmineCrm::ActsAsDraftable::InstanceMethods
+      end
+    end # Base
+
+    module ClassMethods
+      def draftable?
+        true
+      end
+
+      def from_draft(draft_or_id)
+        draft = draft_or_id.is_a?(Draft) ? draft_or_id : Draft.find(draft_or_id)
+        raise ArgumentError unless draft.target_type == name
+
+        target = draft.target_type.constantize.new
+        target.load_from_draft(draft.data)
+
+        target.send("#{draft_parent}=", draft.parent) if draft_parent
+        target.draft_id = draft.id
+        target
+      end
+
+      def drafts(user)
+        Draft.where(user: user, target_type: name)
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      def save_draft(user = nil)
+        return false unless self.new_record?
+
+        draft = Draft.find_by_id(self.draft_id) || Draft.new
+
+        draft.data = dump_to_draft
+        draft.target_type = self.class.name
+        draft.user = user
+        draft.parent = self.send(self.class.draft_parent) if self.class.draft_parent
+
+        result = draft.save
+        self.draft_id = draft.id if result
+        result
+      end
+
+      def update_draft(user, attributes)
+        with_transaction_returning_status do
+          assign_attributes(attributes)
+          save_draft(user)
+        end
+      end
+
+      def dump_to_draft
+        Marshal.dump(instance_values)
+      end
+
+      def load_from_draft(string)
+        values = Marshal.load(string)
+
+        values.each do |name, value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      private
+
+      def clear_draft
+        if draft = Draft.find_by_id(self.draft_id)
+          self.draft_id = nil if draft.destroy
+        end
+      end
+    end # InstanceMethods
+
+    module Migration
+      def create_drafts_table
+        return if connection.table_exists?(:drafts)
+
+        connection.create_table :drafts do |t|
+          t.string :target_type, limit: 150, null: false
+          t.references :user
+          t.references :parent, polymorphic: true, index: true
+          t.binary :data, limit: 16777215, null: false
+          t.datetime :updated_at, null: false
+        end
+
+        connection.add_index :drafts, [:user_id, :target_type]
+      end
+
+      def drop_drafts_table
+        connection.drop_table :drafts if connection.table_exists?(:drafts)
+      end
+    end # Migration
+  end
+end
+
+ActiveRecord::Base.extend RedmineCrm::ActsAsDraftable::Base
+ActiveRecord::Base.extend RedmineCrm::ActsAsDraftable::Migration