redmine_crm 0.0.23 → 0.0.43

data/lib/redmine_crm/liquid/drops/issues_drop.rb

@@ -0,0 +1,191 @@
+module RedmineCrm
+  module Liquid
+    class IssuesDrop < ::Liquid::Drop
+      def initialize(issues)
+        @issues = issues
+      end
+
+      def before_method(id)
+        issue = @issues.where(:id => id).first || Issue.new
+        IssueDrop.new issue
+      end
+
+      def all
+        @all ||= @issues.map do |issue|
+          IssueDrop.new issue
+        end
+      end
+
+      def visible
+        @visible ||= @all.select(&:visible?)
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @issues.size
+      end
+    end
+
+    class IssueDrop < ::Liquid::Drop
+      include ActionView::Helpers::UrlHelper
+
+      delegate :id,
+               :subject,
+               :description,
+               :visible?,
+               :open?,
+               :start_date,
+               :due_date,
+               :overdue?,
+               :done_ratio,
+               :estimated_hours,
+               :spent_hours,
+               :total_spent_hours,
+               :total_estimated_hours,
+               :is_private?,
+               :closed_on,
+               :updated_on,
+               :created_on,
+               :to => :@issue
+
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def link
+        link_to @issue.subject, self.url
+      end
+
+      def url
+        Rails.application.routes.url_helpers.issue_path(@issue)
+      end
+
+      def author
+        @user ||= UserDrop.new(@issue.author)
+      end
+
+      def assignee
+        @assignee ||= UserDrop.new(@issue.assigned_to)
+      end
+
+      def tracker
+        @tracker ||= @issue.tracker && @issue.tracker.name
+      end
+
+      def status
+        @status ||= @issue.status && @issue.status.name
+      end
+
+      def priority
+        @priority ||= @issue.priority && @issue.priority.name
+      end
+
+      def category
+        @category ||= @issue.category && @issue.category.name
+      end
+
+      def version
+        @version ||= @issue.fixed_version && @issue.fixed_version.name
+      end
+
+      def time_entries
+        @time_entries ||= TimeEntriesDrop.new @issue.time_entries
+      end
+
+      def parent
+        @parent ||= IssueDrop.new @issue.parent if @issue.parent 
+      end
+
+      def project
+        @project ||= ProjectDrop.new @issue.project if @issue.project 
+      end
+
+      def subtasks
+        @subtasks ||= IssuesDrop.new @issue.children 
+      end
+
+      def notes
+        @notes ||= @issue.journals.where("#{Journal.table_name}.notes IS NOT ?", nil).order(:created_on).map(&:notes)
+      end
+
+      def journals
+        @journals ||= JournalsDrop.new @issue.journals.where("#{Journal.table_name}.notes IS NOT ?", nil)
+      end
+
+      def tags
+        @issue.respond_to?(:tag_list) && @issue.tag_list
+      end
+
+      def story_points
+        @issue.respond_to?(:story_points) && @issue.story_points
+      end
+
+      def color
+        @issue.respond_to?(:color) && @issue.color
+      end
+      
+      def day_in_state
+        @issue.respond_to?(:day_in_state) && @issue.day_in_state
+      end
+
+      def checklists
+        @issue.respond_to?(:checklists) && @issue.checklists.map{|item| {"id_done" => item.is_done, "subject" => item.subject}}
+      end
+
+      def custom_field_values
+        @issue.custom_field_values
+      end      
+
+    end
+
+    class JournalsDrop < ::Liquid::Drop
+      def initialize(journals)
+        @journals = journals
+      end
+
+      def all
+        @all ||= @journals.map do |journal|
+          JournalDrop.new journal
+        end
+      end
+
+      def visible
+        @visible ||= @all.select(&:visible?)
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @journals.size
+      end
+    end
+
+    class JournalDrop < ::Liquid::Drop
+      delegate :id,
+               :notes,
+               :created_on,
+               :private_notes,
+               :to => :@journal, 
+               allow_nil: true
+
+      def initialize(journal)
+        @journal = journal
+      end
+
+      def user
+        @user ||= UserDrop.new(@journal.user)
+      end
+
+      def issue
+        @issue ||= IssueDrop.new @journal.issue if @journal.issue 
+      end
+
+    end
+
+  end
+end

data/lib/redmine_crm/liquid/drops/news_drop.rb

@@ -0,0 +1,54 @@
+module RedmineCrm
+  module Liquid
+    class NewssDrop < ::Liquid::Drop
+
+      def self.default_drop
+        self.new News.visible.order("#{News.table_name}.created_on")
+      end
+
+      def initialize(newss)
+        @newss = newss
+      end
+
+      def before_method(id)
+        news = @newss.where(:id => id).first || News.new
+        NewsDrop.new news
+      end
+
+      def last
+        NewsDrop.new News.last
+      end
+
+      def all
+        @all ||= @newss.map do |news|
+          NewsDrop.new news
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @newss.size
+      end
+    end
+
+    class NewsDrop < ::Liquid::Drop
+      delegate :id, :title, :summary, :description, :visible?, :commentable?, :to => :@news
+
+      def initialize(news)
+        @news = news
+      end
+
+      def author
+        UserDrop.new @news.author
+      end
+
+      def custom_field_values
+        @news.custom_field_values
+      end   
+            
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/projects_drop.rb

@@ -0,0 +1,86 @@
+module RedmineCrm
+  module Liquid
+    class ProjectsDrop < ::Liquid::Drop
+
+      def self.default_drop
+        self.new Project.visible.order(:name)
+      end
+
+      def initialize(projects)
+        @projects = projects
+      end
+
+      def before_method(identifier)
+        project = @projects.where(:identifier => identifier).first || Project.new
+        ProjectDrop.new project
+      end
+
+      def all
+        @all ||= @projects.map do |project|
+          ProjectDrop.new project
+        end
+      end
+
+      def active
+        @active ||= @projects.select(&:active?).map do |project|
+          ProjectDrop.new project
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @projects.size
+      end
+    end
+
+    class ProjectDrop < ::Liquid::Drop
+      include ActionView::Helpers::UrlHelper
+
+      delegate :id,
+               :identifier,
+               :name,
+               :is_public,
+               :description,
+               :visible?,
+               :active?,
+               :archived?,
+               :short_description,
+               :start_date,
+               :due_date,
+               :overdue?,
+               :completed_percent,
+               :to => :@project
+
+      def initialize(project)
+        @project = project
+      end
+
+      def link
+        link_to @project.name, self.url
+      end
+
+      def url
+        Rails.application.routes.url_helpers.project_path(@project)
+      end
+
+      def issues
+        @issues ||= IssuesDrop.new @project.issues
+      end
+
+      def users
+        @users ||= UsersDrop.new @project.users
+      end
+
+      def subprojects
+        @subprojects ||= ProjectsDrop.new @project.children
+      end
+
+      def custom_field_values
+        @project.custom_field_values
+      end         
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/time_entries_drop.rb

@@ -0,0 +1,65 @@
+module RedmineCrm
+  module Liquid
+    class TimeEntriesDrop < ::Liquid::Drop
+      def initialize(time_entries)
+        @time_entries = time_entries
+      end
+
+      def all
+        @all ||= @time_entries.map do |time_entry|
+          TimeEntryDrop.new time_entry
+        end
+      end
+
+      def visible
+        @visible ||= @all.select(&:visible?)
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @time_entries.size
+      end
+    end
+
+    class TimeEntryDrop < ::Liquid::Drop
+      include ActionView::Helpers::UrlHelper
+
+      delegate :id,
+               :hours,
+               :comments,
+               :spent_on,
+               :tyear,
+               :tmonth,
+               :tweek,
+               :visible?,
+               :updated_on,
+               :created_on,
+               :to => :@time_entry, 
+               allow_nil: true
+
+      def initialize(time_entry)
+        @time_entry = time_entry
+      end
+
+      def user
+        @user ||= UserDrop.new(@time_entry.user)
+      end
+
+      def issue
+        @issue ||= IssueDrop.new(@time_entry.issue)
+      end
+
+      def activity
+        @activity ||= @time_entry.activity && @time_entry.activity.name
+      end
+
+      def custom_field_values
+        @time_entry.custom_field_values
+      end      
+
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/users_drop.rb

@@ -0,0 +1,68 @@
+module RedmineCrm
+  module Liquid
+    class UsersDrop < ::Liquid::Drop
+
+      def self.default_drop
+        self.new User.sorted
+      end
+
+      def initialize(users)
+        @users = users
+      end
+
+      def before_method(login)
+        user = @users.where(:login => login).first || User.new
+        UserDrop.new user
+      end
+
+      def current
+        UserDrop.new User.current
+      end
+
+      def all
+        @all ||= @users.map do |user|
+          UserDrop.new user
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @users.size
+      end
+    end
+
+    class UserDrop < ::Liquid::Drop
+      delegate :id, :name, :firstname, :lastname, :mail, :active?, :admin?, :logged?, :language, :to => :@user, allow_nil: true
+
+      def initialize(user)
+        @user = user
+      end
+
+      def avatar
+        ApplicationController.helpers.avatar(@user)
+      end
+
+      def permissions
+        roles = @user.memberships.collect { |m| m.roles }.flatten.uniq
+        roles << (@user.logged? ? Role.non_member : Role.anonymous)
+        roles.map(&:permissions).flatten.uniq.map(&:to_s)
+      end
+
+      def groups
+        @user.groups.map(&:name)
+      end
+
+      def projects
+        ProjectsDrop.new @user.memberships.map(&:project).flatten.select(&:visible?).uniq
+      end
+
+      def custom_field_values
+        @user.custom_field_values
+      end         
+      
+    end
+  end
+end

data/lib/redmine_crm/liquid/filters/arrays.rb

@@ -0,0 +1,187 @@
+module RedmineCrm
+  module Liquid
+    module Filters
+      module Arrays
+
+        # Get the first element of the passed in array
+        #
+        # Example:
+        #    {{ product.images | first | to_img }}
+        # 
+        #    {{ product.images | first: 3 }}
+        #
+        def first(array, count=1)
+          (count > 1 ? array.first(count) : array.first) if array.respond_to?(:first)
+        end
+
+        # Convert the input into json string
+        #
+        # input - The Array or Hash to be converted
+        #
+        # Returns the converted json string
+        def jsonify(input)
+          as_liquid(input).to_json
+        end
+
+        # Group an array of items by a property
+        #
+        # input - the inputted Enumerable
+        # property - the property
+        #
+        # Returns an array of Hashes, each looking something like this:
+        #  {"name"  => "larry"
+        #   "items" => [...] } # all the items where `property` == "larry"
+        def group_by(input, property)
+          if groupable?(input)
+            input.group_by { |item| item_property(item, property).to_s }.each_with_object([]) do |item, array|
+                array << {
+                  "name"  => item.first,
+                  "items" => item.last,
+                  "size"  => item.last.size
+                }
+              end
+          else
+            input
+          end
+        end
+
+        # Filter an array of objects
+        #
+        # input - the object array
+        # property - property within each object to filter by
+        # value - desired value
+        #
+        # Returns the filtered array of objects
+        def where(input, property, value, operator='==')
+          return input unless input.respond_to?(:select)
+          input = input.values if input.is_a?(Hash)
+          if operator == '=='
+            input.select do |object|
+              Array(item_property(object, property)).map(&:to_s).include?(value.to_s)
+            end || []
+          elsif operator == '<>'
+            input.select do |object|
+              !Array(item_property(object, property)).map(&:to_s).include?(value.to_s)
+            end || []
+          elsif operator == '>'
+            input.select do |object|
+              item_property_value = item_property(object, property) 
+              item_property_value && item_property_value > value
+            end || []
+          elsif operator == '<'
+            input.select do |object|
+              item_property_value = item_property(object, property) 
+              item_property_value && item_property_value < value
+            end || []
+          elsif operator == 'match'
+            input.select do |object|
+              Array(item_property(object, property)).map(&:to_s).any?{|i| i.match(value.to_s)}
+            end || []
+          elsif operator == 'any'
+            input.select do |object|
+              item_property(object, property).present?
+            end || []
+          elsif operator == 'none'
+            input.select do |object|
+              item_property(object, property).blank?
+            end || []
+          else
+            []
+          end
+        end
+
+        # Filter an array of objects by tags
+        #
+        # input - the object array
+        # tags - quoted tags list divided by comma
+        # match - (all- defaut, any, exclude)
+        #
+        # Returns the filtered array of objects
+        def tagged_with(input, tags, match='all')
+          return input unless input.respond_to?(:select)
+          input = input.values if input.is_a?(Hash)
+          tag_list = input.is_a?(Array) ? tags.sort : tags.split(',').map(&:strip).sort
+          case match
+          when "all"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list - Array(item_property(object, 'tag_list')).map(&:to_s).sort).empty?
+            end || []
+          when "any"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list & Array(item_property(object, 'tag_list')).map(&:to_s).sort).any?
+            end || []
+          when "exclude"
+            input.select do |object|
+              object.respond_to?(:tag_list) &&
+              (tag_list & Array(item_property(object, 'tag_list')).map(&:to_s).sort).empty?
+            end || []
+          else
+            []
+          end
+        end
+
+        # Sort an array of objects
+        #
+        # input - the object array
+        # property - property within each object to filter by
+        # nils ('first' | 'last') - nils appear before or after non-nil values
+        #
+        # Returns the filtered array of objects
+        def sort(input, property = nil, nils = "first")
+          if input.nil?
+            raise ArgumentError, "Cannot sort a null object."
+          end
+          if property.nil?
+            input.sort
+          else
+            if nils == "first"
+              order = - 1
+            elsif nils == "last"
+              order = + 1
+            else
+              raise ArgumentError, "Invalid nils order: " \
+                "'#{nils}' is not a valid nils order. It must be 'first' or 'last'."
+            end
+
+            sort_input(input, property, order)
+          end
+        end
+
+        def pop(array, input = 1)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.pop(input.to_i || 1)
+          new_ary
+        end
+
+        def push(array, input)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.push(input)
+          new_ary
+        end
+
+        def shift(array, input = 1)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.shift(input.to_i || 1)
+          new_ary
+        end
+
+        def unshift(array, input)
+          return array unless array.is_a?(Array)
+          new_ary = array.dup
+          new_ary.unshift(input)
+          new_ary
+        end
+
+        private
+
+      end # module ArrayFilters
+    end
+  end
+
+  ::Liquid::Template.register_filter(RedmineCrm::Liquid::Filters::Arrays)
+end