your_platform 0.0.1 → 0.0.2

data/app/models/profile_field_types/professional_category.rb

@@ -0,0 +1,8 @@
+module ProfileFieldTypes
+
+  class ProfessionalCategory < ProfileField
+    def self.model_name; ProfileField.model_name; end
+
+  end
+
+end

data/app/models/profile_field_types/study.rb

@@ -0,0 +1,18 @@
+module ProfileFieldTypes
+
+  # Studies Information
+  #
+  class Study < ProfileField
+    def self.model_name; ProfileField.model_name; end
+
+    has_child_profile_fields :from, :to, :university, :subject, :specialization
+
+    # If the single study has no label, just say 'Study'.
+    #
+    def label
+      super || I18n.translate( :study, default: "Study" )
+    end
+
+  end
+  
+end

data/app/models/profile_section.rb

@@ -0,0 +1,49 @@
+class ProfileSection < Struct.new(:title, :profileable)
+
+  def initialize( options = {} )
+    self.title = options[:title] || raise('missing option "title"')
+    self.profileable = options[:profileable] || raise('missing option "profileable"')
+  end
+  
+  def profile_fields
+    profileable.profile_fields.where( type: self.profile_field_types )
+  end
+  def fields
+    profile_fields
+  end
+  
+  def profile_field_types
+    case(self.title.to_sym)
+      when :general
+        [ "ProfileFieldTypes::AcademicDegree", "ProfileFieldTypes::General" ]
+      when :contact_information
+        [ "ProfileFieldTypes::Address", "ProfileFieldTypes::Email", 
+          "ProfileFieldTypes::Phone", "ProfileFieldTypes::Homepage", "ProfileFieldTypes::Custom" ]
+      when :about_myself
+        [ "ProfileFieldTypes::About" ]
+      when :study_information
+        [ "ProfileFieldTypes::Study" ]
+      when :career_information
+        [ "ProfileFieldTypes::Employment", "ProfileFieldTypes::ProfessionalCategory", "ProfileFieldTypes::Competence" ]
+      when :organizations
+        [ "ProfileFieldTypes::Organization" ]
+      when :bank_account_information
+        [ "ProfileFieldTypes::BankAccount" ]
+      when :description
+        [ "ProfileFieldTypes::Description" ]
+      when :communication
+        [ "ProfileFieldTypes::NameSurrounding" ]
+      else
+        []
+    end
+    
+  end
+  def field_types
+    profile_field_types
+  end
+  
+  def to_s
+    self.title.to_s
+  end
+  
+end

data/app/models/profileable.rb

@@ -0,0 +1,58 @@
+#
+# This module allows to mark a model (User, Group, ...) as profileable, i.e. have profile fields.
+#
+# The inclusion of this module into ActiveRecord::Base is done in
+# config/initializers/active_record_navable_extension.rb.
+#
+
+module Profileable
+  def has_profile_fields( options = {} )
+    is_profileable(options)
+  end
+
+  def is_profileable( options = {} )
+    @profile_section_titles = options[:profile_sections] || default_profile_section_titles
+    has_many :profile_fields, as: :profileable, dependent: :destroy, autosave: true
+    has_many :address_profile_fields, class_name: 'ProfileFieldTypes::Address', conditions: 'type = "ProfileFieldTypes::Address"', as: :profileable, dependent: :destroy, autosave: true
+    
+    include InstanceMethodsForProfileables
+  end
+  
+  def default_profile_section_titles
+    [:contact_information, :about_myself, :study_information, :career_information, 
+     :organizations, :bank_account_information, :description]
+  end
+  def profile_section_titles 
+    @profile_section_titles
+  end  
+
+  module InstanceMethodsForProfileables
+    
+    def email
+      profile_fields_by_type( "ProfileFieldTypes::Email" ).first.value if profile_fields_by_type( "ProfileFieldTypes::Email" ).first
+    end
+    def email=( email )
+      @email_profile_field = profile_fields_by_type( "ProfileFieldTypes::Email" ).first unless @email_profile_field
+      @email_profile_field = profile_fields.build( type: "ProfileFieldTypes::Email", label: "email" ) unless @email_profile_field
+      @email_profile_field.value = email
+    end
+    
+    def profile
+      @profile ||= Profile.new(self)
+    end
+
+    def profile_section_titles
+      self.class.profile_section_titles
+    end
+    
+    def profile_sections
+      self.profile.sections
+    end
+    
+    def profile_fields_by_type( type_or_types )
+      profile_fields.where( type: type_or_types )
+    end
+    
+  end
+ 
+end

data/app/models/profileable_mixins/address.rb

@@ -0,0 +1,118 @@
+module ProfileableMixins::Address
+  extend ActiveSupport::Concern
+  
+  # Scope for profile fields that are postal addresses.
+  #
+  def address_fields
+    self.id ? profile_fields.where(type: 'ProfileFieldTypes::Address') : profile_fields.where('false')
+  end
+  
+  # The postal address at the study location.
+  #
+  def study_address
+    address_fields.where(label: study_address_labels + work_or_study_address_labels).first.try(:value)
+  end
+  def study_address=(address_string)
+    field = address_fields.where(label: study_address_labels + work_or_study_address_labels).first || address_fields.build(label: study_address_labels.first)
+    field.value = address_string
+    field.label = study_address_labels.first if field.label.in? work_or_study_address_labels
+    field.save
+  end
+  def study_address_labels
+    ["Semesteranschrift", "Studienanschrift", "Study Address"]
+  end
+
+  def work_or_study_address
+    work_address || study_address
+  end
+  def work_or_study_address_labels
+    ["Arbeits- oder Studienanschrift", "Work or Study Address"]
+  end
+  
+  # The postal address of the work place.
+  #
+  def work_address
+    address_fields.where(label: work_address_labels + work_or_study_address_labels).first.try(:value)
+  end
+  def work_address=(address_string)
+    field = address_fields.where(label: work_address_labels + work_or_study_address_labels).first || address_fields.build(label: work_address_labels.first)
+    field.label = work_address_labels.first if field.label.in? work_or_study_address_labels
+    field.value = address_string
+    field.save
+  end
+  def work_address_labels
+    ["Geschäftliche Anschrift", "Arbeitsanschrift", "Dienstanschrift", "Work Address"]
+  end
+
+  # The postal address of the user's home.
+  #
+  def home_address
+    address_fields.where(label: home_address_labels).first.try(:value)
+  end
+  def home_address=(address_string)
+    field = address_fields.where(label: home_address_labels).first || address_fields.build(label: home_address_labels.first)
+    field.value = address_string
+    field.save
+  end
+  def home_address_labels
+    ["Heimatanschrift", "Private Anschrift", "Home Address"]
+  end
+  
+  # Primary Postal Address
+  #
+  def postal_address_field
+    self.address_profile_fields.select do |address_field|
+      address_field.postal_address? == true
+    end.first
+  end
+  
+  # Primary Postal Address or, if not existent, the first address field.
+  #
+  def postal_address_field_or_first_address_field
+    postal_address_field || address_profile_fields.where("value != ? AND NOT value IS NULL", '').first
+  end
+
+  # This method returns the postal address of the user.
+  # If one address of the user has got a :postal_address flag, this address is used.
+  # Otherwise, the first address of the user is used.
+  #
+  def postal_address
+    cached { postal_address_field_or_first_address_field.try(:value) }
+  end
+  
+  def postal_address_in_one_line
+    postal_address.split("\n").collect { |line| line.strip }.join(", ") if postal_address
+  end
+
+  # Returns when the postal address has been updated last.
+  #
+  def postal_address_updated_at
+    cached do
+      # if the date is earlier, the date is actually the date
+      # of the data migration and should not be shown.
+      #
+      if postal_address_field_or_first_address_field && postal_address_field_or_first_address_field.updated_at.to_date > "2014-02-28".to_date 
+        postal_address_field_or_first_address_field.updated_at.to_date 
+      end
+    end
+  end
+  
+  included do
+  end
+
+  module ClassMethods
+    
+    def with_postal_address
+      self.joins(:address_profile_fields).where('profile_fields.profileable_id IS NOT NULL AND profile_fields.value != ""').uniq
+    end
+  
+    def with_postal_address_ids
+      self.with_postal_address.pluck(:id)
+    end
+  
+    def without_postal_address
+      self.where('NOT users.id IN (?)', self.with_postal_address_ids)
+    end
+    
+  end
+end

data/app/models/relationship.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+# This class models a relationship between two users.
+#
+# For example, John is the brother of Sue. 
+#
+#   who: John        relationship.user1    relationship.who
+#   is:  Brother     relationship.is       relationship.name
+#   of:  Sue         relationship.user2    relationship.of
+#
+class Relationship < ActiveRecord::Base
+
+  attr_accessible :user1, :user2, :name, :who, :is, :of, :who_by_title, :of_by_title
+
+  belongs_to :user1, class_name: "User", inverse_of: :relationships_as_first_user
+  belongs_to :user2, class_name: "User", inverse_of: :relationships_as_second_user
+
+  # John is the brother of Sue.
+  # ----                           who: John
+  #
+  def who
+    self.user1
+  end
+  def who=( user )
+    self.user1 = user
+  end
+
+  # John is the brother of Sue.
+  #             -------           is: brother
+  #
+  def is
+    self.name
+  end
+  def is=( name )
+    self.name = name
+  end
+
+  # John is the brother of Sue.
+  #                        ---    of: Sue
+  #
+  def of 
+    self.user2
+  end
+  def of=( user )
+    self.user2 = user
+  end
+
+  # Adding new relationships:
+  # 
+  #     Relationship.add( who: john_user, is: :brother, of: :sue_user )
+  #
+  # which is the same as:
+  #
+  #     Relationship.create( who: john_user, is: :brother, of: :sue_user )
+  #
+  def self.add( params )
+    self.create( params )
+  end
+
+  # Access method for the first user being given by his title.
+  #
+  def who_by_title
+    self.who.title if self.who
+  end
+  def who_by_title=( title )
+    self.who = User.find_by_title( title )
+  end
+  
+  # Access method for the second user being given by his title.
+  #
+  def of_by_title
+    self.of.title if self.of
+  end
+  def of_by_title=( title )
+    self.of = User.find_by_title( title )
+  end
+
+end

data/app/models/role.rb

@@ -0,0 +1,164 @@
+# Example:
+# 
+#   Role.of(user).in(corporation).to_s    #  => "guest"
+#   Role.of(user).in(corporation).guest?  #  => true
+#   Role.find_all_by_user_and_group(user, corporation)
+#
+#   Role.of(user).for(page).to_s          #  => "admin"
+#   Role.of(user).for(user).to_s          #  => "global_admin"
+#
+class Role
+  
+  def initialize(given_user, given_object)
+    @user = given_user
+    @object = given_object
+  end
+  
+  # Example:
+  # 
+  #   Role.of(user).in(corporation).to_s  #  => "guest"
+  #
+  def self.of(given_user)
+    self.new(given_user, nil)
+  end
+
+  # Example:
+  # 
+  #   Role.of(user).in(corporation).to_s  #  => "guest"
+  #
+  def in(given_object)
+    @object = given_object
+    return self
+  end
+  def for(given_object)
+    self.in(given_object)
+  end
+  
+  def user
+    @user || raise('User not given, when trying to determine Role.')
+  end
+  
+  def object
+    @object
+  end
+  def group
+    @object
+  end
+  
+  #
+  # Roles for groups
+  #
+  
+  def current_member?
+    member? && full_member?
+  end
+  
+  def full_member?
+    object.kind_of?(Group) && 
+      (( ([group] + group.descendant_groups) & user.groups.find_all_by_flag(:full_members) ).count > 0)
+  end
+    
+  def member?
+    object && object.kind_of?(Group) && user.member_of?(object)
+  end
+  
+  def guest?
+    object && object.kind_of?(Group) && user.guest_of?(object)
+  end
+  
+  def former_member?
+    object && object.kind_of?(Group) && object.corporation? && user.former_member_of_corporation?(object)
+  end
+  
+  def deceased_member?
+    object && object.kind_of?(Group) && object.corporation? && user.id.in?(object.deceased_members.map(&:id)) && (not former_member?)
+  end
+  
+  #
+  # Roles for structureables
+  #
+  
+  def global_admin?
+    user.global_admin?
+  end
+
+  def admin?
+    global_admin? || (object && object.admins_of_self_and_ancestors.include?(user))
+  end
+  
+  def officer?
+    global_admin? || (object && object.officers_of_self_and_ancestors.include?(user))
+  end
+  
+  
+  # Example
+  #   Role.of(user).for(page).to_s  # => 'admin'
+  def to_s
+    return 'global_admin' if global_admin?
+    return 'admin' if admin?
+    return 'officer' if officer?
+    return 'global_officer' if global_officer?
+    return 'full_member' if full_member?
+    return 'guest' if guest?
+    return 'former_member' if former_member?
+    return 'deceased_member' if deceased_member?
+    return 'member' if member?
+    return ''
+  end
+  
+  #
+  # Global Roles
+  #
+  def global_officer?
+    global_admin? || (user.ancestor_groups.find_all_by_flag(:global_officer).count > 0)
+  end
+  
+  # The system allows to simulate a certain role when viewing an object.
+  # This determines which simulations are allowed.
+  # 
+  def allowed_preview_roles
+    return ['global_admin', 'admin', 'officer', 'global_officer', 'user'] if global_admin?
+    return ['admin', 'officer', 'user'] if admin?
+    return ['officer', 'global_officer', 'user'] if global_officer? and officer?
+    return ['officer', 'user'] if officer?
+    return ['global_officer', 'user'] if global_officer?
+    return []
+  end
+  def allow_preview?
+    # The preview makes sense for officers and above.
+    # All above roles are also officer roles.
+    officer? || global_officer?
+  end
+  
+  # Finding administrated objects.
+  #
+  #   Role.of(user).select_objects_where_user_is_admin(objects)
+  #   Role.of(user).administrated_users
+  #
+  def select_objects_where_user_is_admin(objects)
+    objects & administrated_objects
+  end
+  def admin_groups
+    user.groups.find_all_by_flag(:admins_parent)
+  end
+  def directly_administrated_objects
+    admin_groups.collect { |g| g.parent_groups.first.parents.first } - [nil]
+  end
+  def directly_administrated_groups
+    admin_groups.collect { |g| g.parent_groups.first.parent_groups.first } - [nil]
+  end
+  def administrated_objects
+    directly_administrated_objects + directly_administrated_objects.collect { |o| o.descendants }.flatten
+  end
+  def administrated_users
+    directly_administrated_groups.collect { |g| g.descendant_users }.flatten
+  end
+  
+  
+  # This finder method returns all global admins.
+  #
+  def self.global_admins
+    Group.find_everyone_group.try(:find_admins) || []
+  end
+  
+end