redmine_crm 0.0.23 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb1379b61856d4d51a73e61eaa2af2505559bc55
-  data.tar.gz: dac49994dbd3c6df0727e37b4f1739cdeeb11406
+  metadata.gz: c7ec4763f7c0ff9e5ce0744bcd8579020ed89b32
+  data.tar.gz: 45d4f87a91b17c299097c1f6aa5a9732507f30cc
 SHA512:
-  metadata.gz: 58cad6ac2a7c193331c40f8e897a9462573e4ee126f623b727b5623ec437a921a4b2227aba13b91d625b8d77c1d95fbce24b4b4a580baa4864b1472cb2da38dd
-  data.tar.gz: 70f067cf96642b3dab5d66469eef34daa4c52dd6dac4af215a2c026cc7c1e7551e8771299803c8db5cde6ffa6dd41b578f73a70bc7c89911b872a960114e80db
+  metadata.gz: a604d13c92a5a5e47ff93d7aeb3867c503c1743beb55059502cbc4fd28a2ddadac9e6cc7745e950249aace899dab2ed8e86d7ced27d5682bd2aade9f7c6e6ca3
+  data.tar.gz: d26992ff800bf72702248dd3d3afb416ee15a5432091ed38befa56196a436b75901fc04a328dc742450261d1e59dba55552e33c8a32e985e6834fada408c79dc

data/.gitignore

@@ -4,6 +4,8 @@
 /_yardoc/
 /coverage/
 /pkg/
+/public/
+/test/public/
 /spec/reports/
 /tmp/
 *.bundle
@@ -15,4 +17,5 @@ mkmf.log
 /Guardfile
 /Gemfile.local
 /Gemfile.local.lock
-*.gem
+*.gem
+/.idea/*

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in redmine_crm.gemspec
-gemspec
+gemspec

data/README.md

@@ -1,71 +1,204 @@
 # 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(user: 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
+
+# Drafts will be saved only for new (not persisted) or changed instances.
+puts Message.new.save_draft
+# => true
+persisted = Message.last
+puts persisted.save_draft
+# => false
+persisted.subject = 'other subject'
+puts persisted.save_draft
+# => true
+```
 
-  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

@@ -0,0 +1,42 @@
+# This is a sample build configuration for Ruby.
+# Check our guides at https://confluence.atlassian.com/x/8r-5Mw for more examples.
+# Only use spaces to indent your .yml configuration.
+# -----
+# You can specify a custom docker image from Docker Hub as your build environment.
+
+pipelines:
+  default:
+    - step:
+        name: New ruby
+        image: ruby:2.4.1
+        script:
+          - sed -i "s/'sqlite3'/'sqlite3', '~> 1.3.6'/g" redmine_crm.gemspec
+          - sed -i "s/'mysql2'/'mysql2', '~> 0.4.0'/g" redmine_crm.gemspec
+          - bundle install
+          - bundle exec rake test DB=sqlite
+          - bundle exec rake test DB=postgresql
+          - bundle exec rake test DB=mysql
+        services:
+          - mysql
+          - postgres
+    - step:
+        name: Old ruby
+        image: ruby:1.9.3
+        script:
+          - bundle install
+          - bundle exec rake test DB=mysql
+        services:
+          - mysql
+
+definitions:
+  services:
+    mysql:
+      image: mysql:5.7
+      environment:
+        MYSQL_DATABASE: redmine_crm_test
+        MYSQL_ROOT_PASSWORD: password
+    postgres:
+      image: postgres
+      environment:
+        POSTGRES_DB: redmine_crm_test
+        POSTGRES_PASSWORD: password

data/config/currency_iso.json

@@ -2528,5 +2528,17 @@
     "thousands_separator": ",",
     "iso_numeric": "967",
     "smallest_denomination": 5
+  },
+  "btc": {
+    "priority": 100,
+    "iso_code": "BTC",
+    "name": "Bitcoin",
+    "symbol": "฿",
+    "subunit": "sat",
+    "subunit_to_unit": 100000000,
+    "symbol_first": false,
+    "html_entity": "฿",
+    "decimal_mark": ",",
+    "thousands_separator": "."
   }
 }

data/doc/CHANGELOG

@@ -1,8 +1,87 @@
 == Redmine CRM gem changelog
 
 Redmine crm gem - general functions for plugins (tags, vote, viewing, currency)
-Copyright (C) 2011-2016 RedmineUP
-http://www.redminecrm.com/
+Copyright (C) 2011-2019 RedmineUP
+https://www.redmineup.com/
+ 
+== 2019-05-07 v0.0.43
+
+* custom_field and custom_fields methods added from Reporter plugin
+* Added support for multi email contacts select
+* Fixed Safari select2 bug with moving screen
+* Fixed after_action method compatibility
+
+== 2018-10-24 v0.0.42
+
+* Hotfix for ruby 1.9.3 hashes support
+* Added ci image for ruby 1.9.3
+
+== 2018-10-23 v0.0.41
+
+* New fields for IssueDrop: tags, checklists, story_points, color, day_in_state
+* New Liquid filters for managing colors: darken_color, lighten_color, contrasting_text_color, hex_color, convert_to_brightness_value
+* Fixes for Drops to use nil delegates
+
+== 2018-09-28 v0.0.40
+
+* acts_as_draftable adopted for Redmine projects
+* New Liquid Drops: JournalsDrop, JournalDrop, TimeEntriesDrop, TimeEntryDrop
+* New liquid properties for issues: done_ratio, estimated_hours, spent_hours, total_spent_hours, total_estimated_hours, is_private, closed_on, assignee, tracker, status, priority, category, version, time_entries, parent, project, subtasks, notes, journals
+
+== 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
+
+== 2018-03-05 v0.0.35
+
+* Added select2_tag helper
+
+== 2017-12-22 v0.0.34
+
+* Fixed bug with Redmine 2.x support
+
+== 2017-12-18 v0.0.33
+
+* Rails 5 support (Redmine 4)
+* rcrm_acts_as_list (Redmine 4)
+* Bitcoin currency support
+
+== 2017-07-18 v0.0.32
+
+* charjs added
+
+== 2017-05-29 v0.0.31
+
+* select2 controls for contacts and people
+
+== 2017-05-23 v0.0.30
+
+* Fixed votable vote_by
+
+== 2017-03-21 v0.0.29
+
+* Updated available_tags method 
+
+== 2017-03-17 v0.0.28
+
+* Fixed bug with quote_value
+
+== 2017-03-13 v0.0.27
+
+* Added IP to Votes
+
+== 2017-03-10 v0.0.26
+
+* Liquid gem with base filters and drops for Redmine objects
+
+== 2016-11-12 v0.0.24
+
+* Liquid gem dependency
 
 == 2016-09-28 v0.0.23
 

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,170 @@
+# 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
+        before_save :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.draft_id = draft.id
+        target
+      end
+
+      def drafts(user)
+        Draft.where(user_id: user.id, target_type: name)
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      def save_draft
+        return false unless new_record? || changed?
+
+        draft = self.draft || Draft.new
+        draft.data = dump_to_draft
+        draft.user_id = User.current.try(:id)
+        draft.parent = parent_for_draft
+        draft.target_type = self.class.name
+
+        result = draft.save
+        self.draft_id = draft.id if result
+        result
+      end
+
+      def update_draft(attributes)
+        with_transaction_returning_status do
+          assign_attributes(attributes)
+          save_draft
+        end
+      end
+
+      def draft
+        Draft.find_by_id(draft_id)
+      end
+
+      def parent_for_draft
+        return self if id.present?
+
+        self.class.draft_parent.present? ? send(self.class.draft_parent) : self
+      end
+
+      def last_draft
+        @last_draft ||= RedmineCrm::ActsAsDraftable::Draft.where(
+          target_type: self.class.name,
+          parent_type: parent_for_draft.try(:class).try(:to_s),
+          parent_id:   parent_for_draft.try(:id),
+          user_id:     User.current.try(:id)
+        ).last
+      end
+
+      def dump_to_draft
+        instance_values.default = nil
+        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
+
+      def clear_draft
+        if last_draft && last_draft.destroy
+          self.draft_id = nil
+        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
+          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