your_platform 0.0.1 → 0.0.2

data/app/models/setting.rb

@@ -0,0 +1,9 @@
+class Setting < RailsSettings::CachedSettings
+	attr_accessible :var
+
+  def self.app_name=(name)
+    super(name)
+    Rails.cache.delete_matched 'app_version_footer*'
+  end
+  
+end

data/app/models/status_group.rb

@@ -0,0 +1,28 @@
+# 
+# A StatusGroup is a sub-Group of a Corporation that memberships model the 
+# current status of members within the corporation.
+#
+# At present time, the status of a user within a corporation is unique.
+#
+class StatusGroup < Group
+  
+  def self.find_all_by_corporation(corporation)
+    corporation.leaf_groups.select do |group|
+      group.ancestor_events.count == 0
+    end
+  end
+  
+  def self.find_all_by_user(user, options = {})
+    user_groups = options[:with_invalid] ? user.parent_groups : user.direct_groups
+    user.corporations.collect do |corporation|
+      StatusGroup.find_all_by_corporation(corporation)
+    end.flatten & user_groups
+  end
+  
+  def self.find_by_user_and_corporation(user, corporation)
+    status_groups = (StatusGroup.find_all_by_corporation(corporation) & StatusGroup.find_all_by_user(user))
+    raise "Slection algorithm not unique, yet. Please correct this. Found possible status groups: #{status_groups.map(&:name).join(', ')}." if status_groups.count > 1
+    status_groups.last
+  end
+  
+end

data/app/models/status_group_membership.rb

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+# 
+# This class represents the membership of a user in a status group, i.e. a subgroup of a corporation
+# representing a member status, e.g. the subgroup 'guests' or 'presidents'.
+#
+class StatusGroupMembership < UserGroupMembership
+
+  # Status Group Memberships do have more properties than regular memberships;
+  # those new properties are, e.g., shown in the corporate_vita.
+  # Since rails apparently does not support Multi Table Inheritance,
+  # this associated model takes the additional properties.
+  # 
+  has_one :status_group_membership_info, foreign_key: 'membership_id', inverse_of: :membership #, autosave: true
+
+  delegate( :promoted_by_workflow, :promoted_by_workflow=,
+            :promoted_on_event, :promoted_on_event=,
+            :workflow, :workflow=, 
+            :event, :event=,   # alias methods
+            to: :find_or_create_status_group_membership_info )
+
+  attr_accessible :event_by_name
+
+  # Alias Methods For Delegated Methods
+  # ==========================================================================================
+
+  def create_event( params )
+    find_or_create_status_group_membership_info.create_promoted_on_event( params )
+  end
+
+  # Access the event (promoted_on_event) by its name, since this is the way
+  # most likely done by a user interface.
+  # 
+  # If a new event is created, assign the corporation associated with this status group
+  # as the group of the event.
+  #
+  def event_by_name
+    self.event.name if self.event
+  end
+  def event_by_name=( event_name )
+    if event_name.present?
+      if Event.find_by_name( event_name )
+        self.event = Event.find_by_name( event_name )
+      else
+        self.create_event( name: event_name )
+        self.event.group ||= self.corporation if self.corporation
+        self.event.start_at = self.created_at
+        self.event.save
+      end
+    else
+      self.event = nil
+    end
+  end
+
+
+  # Creator
+  # ==========================================================================================
+
+  def self.create( params )
+    super( params ).becomes StatusGroupMembership 
+  end
+    
+
+  # Finder Methods
+  # ==========================================================================================
+
+  # Returns all memberships in status groups that belong to the given corporation.
+  # 
+  # corporation A
+  #      |------------- status group 1
+  #      |                      |-------- user 1
+  #      |                      |-------- user 2
+  #      |------------- status group 2
+  #                             |-------- user 3
+  # 
+  # The method therefore will return all memberships of subgroups of the corporation.
+  # 
+  def self.find_all_by_corporation( corporation )
+    raise 'Expect parameter to be a Corporation' unless corporation.kind_of? Corporation
+    status_groups = corporation.status_groups
+    status_group_ids = status_groups.collect { |group| group.id }
+    links = self
+      .where(:descendant_type => "User")
+      .where(:ancestor_type => "Group")
+      .where(:ancestor_id => status_group_ids)
+      .order('valid_from')
+    return links
+  end
+
+  # Returns all memberships of the given user in status groups.
+  #
+  def self.find_all_by_user( user )
+    raise 'Expect parameter to be a User' unless user.kind_of? User
+    status_groups = user.status_groups(with_invalid: true)
+    status_group_ids = status_groups.collect { |group| group.id }
+    links = self
+      .where(:descendant_type => "User")
+      .where(:descendant_id => user.id)
+      .where(:ancestor_type => "Group")
+      .where(:ancestor_id => status_group_ids)
+      .order('valid_from')
+    return links
+  end
+
+  # Returns all memberships of the given user in the given corporation.
+  #
+  def self.find_all_by_user_and_corporation( user, corporation )
+    raise 'Expect parameter to be a User' unless user.kind_of? User
+    status_groups = user.status_groups(with_invalid: true)
+    status_groups &= corporation.status_groups
+    status_group_ids = status_groups.collect { |group| group.id }
+    links = self
+      .where(:descendant_type => "User")
+      .where(:descendant_id => user.id)
+      .where(:ancestor_type => "Group")
+      .where(:ancestor_id => status_group_ids)
+      .order('valid_from')
+    return links
+  end
+
+  # This method overrides the default finder method in order to make
+  # sure the returned object is of the StatusGroupMembership type.
+  #
+  def self.find_by_user_and_group( user, group )
+    self
+      .where(ancestor_id: group.id, ancestor_type: 'Group')
+      .where(descendant_id: user.id, descendant_type: 'User')
+      .limit(1)
+      .first
+    
+    # The #becomes method won't work here.
+    #membership = super( user, group )
+    #membership ? StatusGroupMembership.with_invalid.find(membership.id) : nil
+  end
+
+
+  # Save Method 
+  # ==========================================================================================
+
+  # Since several important attributes of this model are delegated, it is likely to change
+  # a delegated attribute without changing a direct attribute. For example:
+  #
+  #    membership.workflow = some_workflow                # workflow is delegated
+  #    membership.changed?                                # => false
+  #    membership.status_group_membership_info.changed?   # => true
+  #    membership.save
+  #
+  # The regular `save` method would fail, because there are `no changes` to the membership
+  # itself. 
+  #
+  # To circumvent this, this save method first saves the delegate model if necessary and 
+  # then calls the regular `save` method.
+  #
+  def save(*args)
+    save_status_group_membership_info_if_changed
+    if changed?
+      return super(*args)
+    else
+      return true
+    end
+  end
+
+  def update_attributes( attributes, options = {} )
+    self.assign_attributes( attributes, options )
+    save
+  end
+
+
+  # Callback Methods for the Delegation to status_group_membership_info
+  # ==========================================================================================
+
+  private 
+  
+  def find_or_create_status_group_membership_info
+    status_group_membership_info || create_status_group_membership_info
+  end
+   
+  # When .save is called on this instance, but only the associated object has changed through 
+  # the delegated methods, this instance is not marked as changed. As a result, any call of 
+  # .save will fail.
+  #
+  # This method compensates for the missing automatism.
+  #
+  def save_status_group_membership_info_if_changed
+    find_or_create_status_group_membership_info.promoted_by_workflow.try(:save)
+    find_or_create_status_group_membership_info.promoted_on_event.try(:save)
+    find_or_create_status_group_membership_info.save
+  end
+
+end

data/app/models/status_group_membership_info.rb

@@ -0,0 +1,54 @@
+class StatusGroupMembershipInfo < ActiveRecord::Base
+  
+  attr_accessible
+
+  belongs_to :membership, touch: true, class_name: "StatusGroupMembership", inverse_of: :status_group_membership_info 
+
+  belongs_to :promoted_by_workflow, foreign_key: 'promoted_by_workflow_id', class_name: "Workflow"
+  belongs_to :promoted_on_event, foreign_key: 'promoted_on_event_id', class_name: "Event"
+
+
+  # Alias Methods
+  # ==========================================================================================
+
+  # Promoted By Workflow
+  # ------------------------------------------------------------------------------------------
+  #
+  # Status Group Memberships can store the workflow that has promoted the user to this
+  # status. This is used, for example, in the corporate vita, since the title of the
+  # promotion workflow is to be shown there, rather than the title of the new status group.
+  # 
+  # Example:
+  #     membership.promoted_by_workflow = workflow   # long form
+  #     membership.workflow = workflow               # short form
+  #     membership.promoted_by_workflow.title        # long form
+  #     membership.workflow.title                    # short form
+  #
+  def workflow
+    self.promoted_by_workflow
+  end
+  def workflow=( workflow )
+    self.promoted_by_workflow = workflow
+  end
+
+  # Promoted On Event
+  # ------------------------------------------------------------------------------------------
+  # 
+  # This stores the event on which the promotion took place that caused the user to be
+  # in this status group.
+  #
+  # Example:
+  #     membership.promoted_on_event = event         # long form
+  #     membership.event = event                     # short form
+  #     membership.promoted_on_event.name            # long form
+  #     membership.event.title                       # short form
+  # 
+  def event
+    self.promoted_on_event
+  end
+  def event=( event )
+    self.promoted_on_event = event
+  end
+
+
+end

data/app/models/structureable.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+
+# This module provides the ActiveRecord::Base extension `is_structureable`, which characterizes
+# a model as part of the global dag_link structure in this project. All structureable objects
+# are nodes of this dag link.
+# 
+# Examples: 
+#     @page1.parent_pages << @page2
+#     @page1.parents # => [ @page2, ... ]
+#     
+#     @group.child_users << @user
+#     @group.children # => [ @user, ... ]
+#     @user.parents # => [ @group, ... ]
+# 
+# For all methods that are provided, please consult the documentations of the 
+# `acts-as-dag` gem and of the `acts_as_paranoid_dag` gem.
+# 
+# This module is included in ActiveRecord::Base via an initializer at
+# config/initializers/active_record_structureable_extension.rb
+#
+module Structureable
+
+  # options: ancestor_class_names, descendant_class_names
+
+  # This method is used to declare a model as structureable, i.e. part of the global 
+  # dag link structure. 
+  # 
+  # Options:
+  #   ancestor_class_names
+  #   descendant_class_names
+  #   link_class_name         (default: 'DagLink')
+  # 
+  # For detailed information on the options, please see the documentation of the
+  # `acts-as-dag` gem, since these options are forwarded to the has_dag_links method.
+  # http://rubydoc.info/github/resgraph/acts-as-dag/Dag#has_dag_links-instance_method
+  # 
+  # Example:
+  #     class Group < ActiveRecord::Base
+  #       is_structureable ancestor_class_names: %w(Group), descendant_class_names: %w(Group User)
+  #     end
+  #     class User < ActiveRecord::Base
+  #       is_structureable ancestor_class_names: %w(Group)
+  #     end
+  # 
+  def is_structureable( options = {} )
+    
+    # default options
+    conf = {
+      :link_class_name => 'DagLink'
+    }
+    conf.update( options )
+
+    # the model is part of the dag link structure. see gem `acts-as-dag`
+    has_dag_links    conf
+
+    
+    before_destroy   :destroy_links
+
+    # see Flagable model.
+    has_many_flags
+
+    # Structureable objects may have special_groups as descendants, e.g. the admins_parent group.
+    # This mixin loads the necessary methods to interact with them.
+    #
+    include StructureableMixins::HasSpecialGroups
+    
+    # To use `prepend` here allows to call `super` in the methods
+    # defined in the module `StructureableInstanceMethods`.
+    #
+    prepend StructureableInstanceMethods
+  end
+
+  module StructureableInstanceMethods
+    
+    # Include Rules, e.g. let this object have admins.
+    # 
+    include StructureableMixins::Roles
+
+    # When a dag node is destroyed, also destroy the corresponding dag links.
+    # Otherwise, there would remain ghost dag links in the database that would
+    # corrupt the integrity of the database. 
+    # 
+    # If the database gets ever messed up like this, delete the concerning
+    # *direct* dag links by hand and then run this rake task to re-create
+    # the indirect dag links:
+    # 
+    #    rake reconstruct_indirect_dag_links:all
+    # 
+    def destroy_dag_links
+
+      # destory only child and parent links, since the indirect links
+      # are destroyed automatically by the DagLink model then.
+      links = self.links_as_parent + self.links_as_child 
+
+      for link in links do
+
+        if link.destroyable?
+          link.destroy
+        else
+
+          # In facty, all these links should be destroyable. If this error should
+          # be raised, something really went wrong. Please send in a bug report then
+          # at http://github.com/fiedl/your_platform.
+          raise "Could not destroy dag links of the structureable object that should be deleted." +
+            " Please send in a bug report at http://github.com/fiedl/your_platform."
+          return false
+        end  
+
+      end  
+    end
+    
+    # This somehow identifies which are the ancestors of this structureable.
+    # For example, this is used in the breadcrumb helper.
+    #
+    def ancestors_cache_key
+      "Group#{ancestor_group_ids if respond_to?(:ancestor_group_ids)}Page#{ancestor_page_ids if respond_to?(:ancestor_page_ids)}User#{ancestor_user_ids if respond_to?(:ancestor_user_ids)}"
+    end
+    def children_cache_key
+      "Group#{child_group_ids.sum if respond_to?(:child_group_ids)}Page#{child_page_ids.sum if respond_to?(:child_page_ids)}User#{child_user_ids.sum if respond_to?(:child_user_ids)}"
+    end
+
+    def destroy_links
+      self.destroy_dag_links
+    end
+    
+    # Move the node to another parent.
+    #
+    def move_to(parent_node)
+      raise 'Case not handled, yet. This node has several parents. Not moving.' if self.parents.count > 1
+      if parent_node != self.parents.first
+        self.links_as_child.destroy_all
+        parent_node << self
+      end
+    end
+    
+    # Adding child objects.
+    #
+    def <<(object)
+      if object.kind_of? User
+        raise 'Users can only be assigned to groups.' unless self.kind_of? Group
+        self.assign_user(object) unless self.child_users.include? object
+      elsif object.kind_of? Group
+        if self.kind_of?(Group) &&
+          (existing_link = DagLink.where(ancestor_type: 'Group', descendant_type: 'Group',
+            ancestor_id: self.id, descendant_id: object.id,
+            direct: false).first)
+          existing_link.make_direct
+        else
+          self.child_groups << object unless self.child_groups.include? object
+        end
+      elsif object.kind_of? Page
+        self.child_pages << object unless self.child_pages.include? object
+      elsif object.kind_of? Event
+        self.child_events << object unless self.child_events.include? object
+      elsif object.nil?
+        raise "Something is wrong! You've tried to add nil."
+      else
+        raise "Case not handled yet. Please implement this. It's easy :)"
+      end
+    end
+    
+    
+  end
+end

data/app/models/structureable_mixins/has_special_groups.rb

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+
+# This module extends the Structureable models by methods for the interaction with special_groups
+# that are descendants of the structureable object.
+#
+# For example,
+#
+#     class Page
+#       is_structureable ...
+#       ...
+#     end
+#
+# one would want to access the `officers_parent` group, which contains all officers of the 
+# structureable object. 
+#
+#     some_page.find_officers_parent_group
+#     some_page.create_officers_parent_group
+#     some_page.find_or_create_officers_parent_group
+#     some_page.officers_parent
+#     some_page.officers_parent!
+#     some_page.officers
+#     some_page.officers << some_users
+#
+# Or, globally, one would use this mechanism to define, let's say, global special groups
+# like the group 'everyone', which contains each and every user.
+#
+#     class Group
+#       is_structureable ...
+#       ...
+#     end
+#
+#     Group.find_everyone_group
+#     Group.create_everyone_group
+#     Group.find_or_create_everyone_group
+#     Group.everyone
+#     Group.everyone!
+#
+# The `officers_parent` special group is actually defined in `StructureableMixins::Roles`,
+# the `everyone` group in `GroupMixins::GlobalSpecialGroups`, whereas the helper methods that
+# are used by those definitions are defined here in this mixin below.
+#
+module StructureableMixins::HasSpecialGroups
+
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  # Global Special Groups
+  # e.g. the everyone group: `Group.everyone`
+  # ==========================================================================================
+  #
+  # These class methods may be called on each structureable model.
+  # For example, one may call `Group.find_or_create_special_group(:everyone)`.
+  # This is, for example, used to define the `Group.everyone` accessor.
+  #
+  #     class Group
+  #       def self.everyone
+  #         self.find_or_create_special_group(:everyone)
+  #       end
+  #     end
+  # 
+  # The `options` hash allows to specify a `parent element`, which is a structureable element
+  # that is expected to be the parent element of the special group. Example:
+  # 
+  #     find_or_create_special_group( :corporations, parent_element: 
+  #       find_or_create_special_group(:everyone) )
+  #
+  module ClassMethods
+
+    def find_special_group( group_flag, options = {} )
+      object_to_search = options[:parent_element].try(:child_groups) 
+      object_to_search ||= Group unless options[:local]
+      object_to_search.find_by_flag( group_flag.to_sym ) if object_to_search && object_to_search != [] 
+    end
+
+    def create_special_group( group_flag, options = {} )
+      if find_special_group( group_flag, options )
+        raise "special group :#{group_flag} already exists."
+      end
+      object_to_create = options[:parent_element].try(:child_groups) 
+      object_to_create ||= Group unless options[:local]
+
+      new_special_group = object_to_create.create
+      new_special_group.add_flag( group_flag.to_sym )
+      new_special_group.update_attribute( :name, group_flag.to_s.gsub(/_parent$/, "" ) )
+
+      return new_special_group
+    end
+
+    def find_or_create_special_group( group_flag, options = {} )
+      find_special_group(group_flag, options) or
+      begin
+        create_special_group(group_flag, options)
+      rescue
+        nil
+      end
+    end
+
+  end
+
+
+  # Local Special Groups
+  # i.e. descendants of structureables, e.g. officers groups: `group_xy.officers_parent`
+  # ==========================================================================================
+  # 
+  # These instance methods may be called on each structureable model instance.
+  # For example, one may call `my_group.find_or_create_special_group(:officers_parent)`.
+  #
+  # These methods use the same mechanism as for the global special groups above
+  # by specifying `self` (i.e. the structureable instance) as the `parent_element`.
+  #
+
+  def find_special_group( group_flag, options = {} )
+    self.class.find_special_group( group_flag, { parent_element: self, local: true }.merge(options) )
+  end
+
+  def create_special_group( group_flag, options = {} )
+    self.class.create_special_group( group_flag, { parent_element: self, local: true }.merge(options) )
+  end
+
+  def find_or_create_special_group( group_flag, options = {} )
+    self.class.find_or_create_special_group( group_flag, { parent_element: self, local: true }.merge(options) ) 
+  end
+
+end
+