user_parser.rb 3.14 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
module Banzai
  module ReferenceParser
    class UserParser < BaseParser
      self.reference_type = :user

      def referenced_by(nodes)
        group_ids = []
        user_ids = []
        project_ids = []

        nodes.each do |node|
          if node.has_attribute?('data-group')
            group_ids << node.attr('data-group').to_i
          elsif node.has_attribute?(self.class.data_attribute)
            user_ids << node.attr(self.class.data_attribute).to_i
          elsif node.has_attribute?('data-project')
            project_ids << node.attr('data-project').to_i
          end
        end

        find_users_for_groups(group_ids) | find_users(user_ids) |
          find_users_for_projects(project_ids)
      end

      def nodes_visible_to_user(user, nodes)
        group_attr = 'data-group'
        groups = lazy { grouped_objects_for_nodes(nodes, Group, group_attr) }
        visible = []
        remaining = []

        nodes.each do |node|
          if node.has_attribute?(group_attr)
33
            next unless can_read_group_reference?(node, user, groups)
34

35 36 37
            visible << node
          elsif can_read_project_reference?(node)
            visible << node
38 39 40 41 42
          else
            remaining << node
          end
        end

43 44 45 46
        # If project does not belong to a group
        # and does not have the same project id as the current project
        # base class will check if user can read the project that contains
        # the user reference.
47 48 49
        visible + super(current_user, remaining)
      end

50 51 52
      # Check if project belongs to a group which
      # user can read.
      def can_read_group_reference?(node, user, groups)
53
        node_group = groups[node]
54 55 56 57 58 59 60 61 62 63

        node_group && can?(user, :read_group, node_group)
      end

      def can_read_project_reference?(node)
        node_id = node.attr('data-project').to_i

        project && project.id == node_id
      end

64 65 66 67 68 69 70 71 72 73 74 75 76 77
      def nodes_user_can_reference(current_user, nodes)
        project_attr = 'data-project'
        author_attr = 'data-author'

        projects = lazy { projects_for_nodes(nodes) }
        users = lazy { grouped_objects_for_nodes(nodes, User, author_attr) }

        nodes.select do |node|
          project_id = node.attr(project_attr)
          user_id = node.attr(author_attr)

          if project && project_id && project.id == project_id.to_i
            true
          elsif project_id && user_id
78 79
            project = projects[node]
            user = users[node]
80 81 82 83 84 85 86 87 88 89 90

            project && user ? project.team.member?(user) : false
          else
            true
          end
        end
      end

      def find_users(ids)
        return [] if ids.empty?

91
        collection_objects_for_ids(User, ids)
92 93 94 95 96 97 98 99 100 101 102
      end

      def find_users_for_groups(ids)
        return [] if ids.empty?

        User.joins(:group_members).where(members: { source_id: ids }).to_a
      end

      def find_users_for_projects(ids)
        return [] if ids.empty?

103 104
        collection_objects_for_ids(Project, ids)
          .flat_map { |p| p.team.members.to_a }
105
      end
106

107
      def can_read_reference?(user, ref_project, node)
108 109
        can?(user, :read_project, ref_project)
      end
110 111 112
    end
  end
end