your_platform 0.0.1 → 0.0.2

data/app/models/password.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+class Password < String
+  
+  PASSWORD_LENGTH = 12
+
+  # This simply creates a new password using `pwgen`.
+  # Example: 
+  #     new_password = Password.generate
+  def self.generate
+    return pwgen_password if pwgen_password.length == PASSWORD_LENGTH
+    return Passgen::generate( pronounceable: true )
+  end
+  
+  # Example:
+  #    new_password = Password.new
+  #    new_password.generate!
+  def generate!
+    replace self.class.generate
+  end
+
+  def self.pwgen_password
+    Password.new( `pwgen #{PASSWORD_LENGTH} -N 1 -n -c -B`.to_s[0..-2] )
+  end
+  
+end
+
+

data/app/models/post.rb

@@ -0,0 +1,199 @@
+class Post < ActiveRecord::Base
+  attr_accessible :author_user_id, :external_author, :group_id, :sent_at, :sticky, :subject, :text
+  belongs_to :group
+  belongs_to :author, :class_name => "User", foreign_key: 'author_user_id'
+
+  # This creates a new post from the information given in the `message`.
+  # `message` is a `Mail::Message` object (from `ActionMailer::Base`.
+  # See spec/factories/mail_message.rb.
+  #
+  def self.create_from_message(message)
+
+    # http://stackoverflow.com/questions/4868205
+    body = (message.html_part || message.text_part || message).body_in_utf8
+
+    # extract the content of the body tag if necessary
+    if body.include?('<body')
+      doc = Nokogiri::HTML( body )
+      body = doc.xpath( '//body' ).first.inner_html
+    end
+
+    new_post = self.create(subject: message.subject, text: body, sent_at: message.date)
+    new_post.author = message.from.first
+    new_post.set_group_by_email_address(message.to.first)
+    new_post.entire_message = message
+    new_post.save
+    return new_post
+  end
+
+  # TODO: create_multiple_from_message
+
+  # This allows to set the author either as email or as email string.
+  #
+  def author=(author)
+    if author.kind_of? User
+      super(author)
+    elsif author.kind_of? String
+      users_by_email = User.find_all_by_email(author) 
+      user_by_email = users_by_email.first if users_by_email.count == 1
+      if user_by_email
+        super(user_by_email)
+      else
+        self.external_author = author
+      end
+    end
+  end
+  def author
+    super || external_author
+  end
+
+  # This sets the group this message belongs to, identifying the group by its email token.
+  #
+  def set_group_by_email_address(email_address)
+    token = email_address.split("@").first
+    groups = Group.select { |group| group.name && group.name.parameterize == token } 
+    # TODO Make this efficient, e.g. by email_token attribute
+    self.group = groups.first if groups.count == 1
+  end
+
+  # In order to do the encoding conversion properly,
+  # we have to find out the former encoding from the mail header.
+  # 
+  # parameter: Mail object
+  # #<Mail::Part:-570274288, Multipart: false, Headers: <Content-Type: text/html; charset=windows-1252>, 
+  #   <Content-Transfer-Encoding: quoted-printable>>
+  # 
+  def self.mail_encoding(mail)
+    mail.inspect.to_s.scan(/.charset=(.*)>./)[0][0].split(">").first if mail
+  end
+
+  
+  # This returns the text attribute, i.e. the message body, without html tags,
+  # which could be used in block quotes, where only an excerpt of the message
+  # is shown. (Use this to avoid opened but not closed html tags.)
+  #
+  def text_without_html_tags
+    # http://stackoverflow.com/questions/7414267/strip-html-from-string-ruby-on-rails
+    HTML::FullSanitizer.new.sanitize(self.text)
+  end
+
+
+  # Delivering Post as Email to All Group Members
+  # ==========================================================================================
+
+  # Each post may be delivered to all group members via email. ("Group Mail Feature").
+  # This method returns the message to deliver to the group members.
+  # This is done separately (i.e. one user at a time) in order to (a) not reveal the 
+  # email addresses, and (b) avoid being caught by a spam filter.
+  #
+  # Calling this method will produce, *not deliver* the mail messages.
+  # 
+  def messages_to_deliver_to_mailing_list_members
+    self.group.descendant_users.collect do |user|
+      message_for_email_delivery_to_user(user)
+    end
+  end
+
+  # This method returns the modified subject, which is used by the Group Mail Feature.
+  # Give a post subject 'My Fancy Subject" and the post's group's name being "Test Group",
+  # this mehtod returns "[Test Group] My Fancy Subject". 
+  #
+  # If the subject already contains the prefix, like in "Re: [Test Group] My Fancy Subject", 
+  # of cause, the prefix isn't added, twice.
+  #
+  def modified_subject
+    prefix = "[#{self.group.name}] "
+    if self.subject.include? prefix
+      return subject
+    else
+      return prefix + subject
+    end
+  end
+
+  # This method returns a mail footer, which may be added to the messages delivered via
+  # email. The footer contains, e.g. a link to the group's site.
+  #
+  def mailing_list_footer
+    "\n\n\n" + 
+      "_____________________________________\n" +
+      I18n.t(:this_message_has_been_deliverd_through_mailing_list, group_name: self.group.name ) + "\n" +
+      self.group.url + "\n"
+  end
+
+  # This method returns the modified message, ready for delivery via email
+  # to the specified user.
+  #
+  def message_for_email_delivery_to_user( user )
+
+    # use the stored message as template
+    message = self.entire_message
+    
+    # modify the subject according to the group's name
+    message.subject = self.modified_subject
+
+    # modify the envelope_to field, but keep the to field as it is.
+    # Thereby, the group mail address is shown in the mail programs
+    # as recipient.
+    message.smtp_envelope_to = user.email
+
+    # add the footer for each part
+    message.add_to_body self.mailing_list_footer
+    
+    return message
+  end
+
+end
+
+
+
+module Mail
+  class Message
+
+    # This returns the message body in utf8 encoding.
+    # 
+    def body_in_utf8
+      CharlockHolmes
+      require 'charlock_holmes/string'
+
+      body = self.body.decoded
+      if body.present?
+        encoding = body.detect_encoding[:encoding]
+        body = body.force_encoding(encoding).encode('UTF-8')
+      end
+      return body
+    end
+
+    # This method adds the given string to all plain text parts of the message.
+    # For multipart messages, this simply adds a part containing the text_to_add.
+    # This is used for email footers.
+    # 
+    # Attention: Multipart emails may have a tree structure, i.e. a part
+    # may contain several other parts. Therefore, this method calls itself
+    # recursively. 
+    # 
+    def add_to_body( text_to_add )
+      CharlockHolmes
+      require 'charlock_holmes/string'
+
+      if self.multipart?
+
+        # Simply add another part.
+        # According to the documentation, this call will add another part 
+        # rather than wiping all.
+        self.body = text_to_add
+
+      else
+        
+        # plain text parts
+        if self.content_type == nil || self.content_type.include?('text/plain')
+          self.body = self.body_in_utf8 + text_to_add.encode('UTF-8')
+        end
+
+      end
+
+      return self
+    end
+
+  end
+end
+

data/app/models/profile.rb

@@ -0,0 +1,36 @@
+class Profile
+  def initialize(profileable)
+    @profileable = profileable
+  end
+  
+  def profileable
+    @profileable
+  end
+  
+  def profile_fields
+    @profileable.profile_fields
+  end
+  def fields
+    profile_fields
+  end
+  
+  def sections
+    @profileable.profile_section_titles.collect do |title|
+      section_by_title(title)
+    end
+  end
+  
+  def section(title)
+    section_by_title(title)
+  end
+
+  def section_by_title(title)
+    sections_by_title([title]).first
+  end
+  def sections_by_title(titles)
+    titles.collect do |title|
+      ProfileSection.new( title: title, profileable: @profileable )
+    end
+  end
+
+end

data/app/models/profile_field.rb

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+class ProfileField < ActiveRecord::Base
+
+  attr_accessible        :label, :type, :value, :key, :profileable_id, :profileable_type
+
+  belongs_to             :profileable, polymorphic: true
+  
+  include ProfileFieldMixins::HasChildProfileFields
+  
+  # Only allow the type column to be an existing class name.
+  #
+  validates_each :type do |record, attr, value| 
+    if value
+      if not ( defined?( value.constantize ) && ( value.constantize.class == Class ) && value.start_with?( "ProfileFieldTypes::" ) )
+        record.errors.add "#{value} is not a ProfileFieldTypes class."
+      end
+    end
+  end
+
+  # There are profile_fields that are composed of other profile_fields.
+  # For example, the BankAccount profile_field type is composed.
+  #
+  #   BankAccount
+  #        |------- ProfileField:  :label => "Account Holder"
+  #        |------- ProfileField:  :label => "Account Number"
+  #        |------- ProfileField:  :label => "Bank Code"
+  #        |------- ProfileField:  :label => "Credit Institution"
+  #        |------- ProfileField:  :label => "IBAN"
+  #        |------- ProfileField:  :label => "BIC"
+  #
+  # You can add this structured ProfileField manually:
+  #
+  #    account = ProfileField.create( label: "Bank Account", type: "BankAccount" )
+  #    account.children.create( label: "Account Holder", value: ... )
+  #    ...
+  #
+  # Or, you can use the customized `create` method of the specialized class BankAccount,
+  # which inherits from ProfileField, to create a blank BankAccount-type profile_field
+  # with all children auto-created empty.
+  #
+  #    account = BankAccount.create( label: "Bank Account" )
+  #
+  acts_as_tree
+
+  # Profile fields may have flags, e.g. :preferred_address.
+  #
+  has_many_flags
+
+  # Often, profile_fields are to be displayed in a certain manner on a HTML page.
+  # This method returns the profile_field's value as HTML code in the way
+  # the profile_field should be displayed.
+  #
+  # Override this in the inheriting classes in ordner to modify the html output
+  # of the value.
+  #
+  def display_html
+    if self.value.try(:include?, "\n")
+      BestInPlace::ViewHelpers.markup(self.value)
+    else
+      self.value
+    end
+  end
+
+  # This method returns the key, i.e. the un-translated label, 
+  # which is needed for child profile fields.
+  #
+  def key
+    read_attribute :label
+  end
+  
+  # This method returns the label text of the profile_field.
+  # If a translation exists, the translation is returned instead.
+  #
+  def label
+    label_text = super
+    label_text = self.underscored_type if not label_text.present?
+    translated_label_text = I18n.translate( label_text, :default => label_text.to_s ) if label_text.present?
+  end
+  
+  # If the field has children, their values are included in the main field's value.
+  # Attention! Probably, you want to display only one in the view: The main value or the child fields.
+  # 
+  def value
+    if children_count > 0
+      ( [ super ] + children.collect { |child| child.value } ).join(", ")
+    else
+      super
+    end
+  end
+  
+  # Overwrite save to ensure that the cache is deleted in case of changes.
+  #
+  def save( *args )
+    delete_cache
+    super( *args )
+  end
+
+  def delete_cache
+    super
+    parent.try(:delete_cache)
+    profileable.delete_cache if profileable && profileable.respond_to?(:delete_cache)
+  end
+  
+  def children_count
+    children.count
+  end
+
+  # Returns a profile field type in an underscored form that can be used as argument for I18n.translate.
+  # Example: For a ProfileFieldTypes::FooBar-type profile field, this method returns 'foo_bar'.
+  #
+  def underscored_type
+    self.type.demodulize.underscore
+  end
+  
+
+  # This creates an easier way to access a composed ProfileField's child field
+  # values. Instead of calling
+  #
+  #    bank_account.children.where( :label => :account_number ).first.value
+  #    bank_account.children.where( :label => :account_number ).first.value = "12345"
+  #
+  # you may call
+  #
+  #    bank_account.account_number
+  #    bank_account.account_number = "12345"
+  #
+  # after telling the profile_field to create these accessors:
+  #
+  #    class BankAccount < ProfileField
+  #      ...
+  #      has_child_profile_fields :account_holder, :account_number, ...
+  #      ...
+  #    end
+  #
+  # Furthermore, this method modifies the intializer to build the child fields
+  # on build of the main profile_field.
+  extend ProfileFieldMixins::HasChildProfileFields
+  
+  # For child profile fields, this returns the profileable of the parent.
+  # For parents, this returns just the assigned profileable.
+  #
+  # This has to be here, since child profile fields do not have the
+  # `has_child_profile_fields` call in their classes.
+  #
+  alias_method :orig_profileable, :profileable
+  def profileable
+    if parent.present?
+      parent.profileable
+    else
+      orig_profileable
+    end
+  end
+  
+
+  # In order to namespace the type classes of the profile_fields, we place them
+  # in a module. In order to be able to use the type column without including
+  # the module, this method makes sure that the module is included in the
+  # type column on save.
+  #
+  # Both versions should work:
+  #     ProfileField.create( label: "My Address", value: "...", type: "Address" )
+  #     ProfileField.create( label: "My Address", value: "...", type: "ProfileField::Address" )
+  #
+  # The long version `ProfileField::...` is stored in the database.
+  #
+  before_save :include_module_in_type_column
+  def include_module_in_type_column
+    type = "ProfileFieldTypes::#{type}" if not type.include?( "::" ) if type
+  end
+  private :include_module_in_type_column
+  
+  
+  # List all possible types. This is needed for code injection security checks.
+  #
+  def self.possible_types
+    [ProfileFieldTypes::General, ProfileFieldTypes::Custom, 
+      ProfileFieldTypes::Organization, ProfileFieldTypes::Email,
+      ProfileFieldTypes::Address, ProfileFieldTypes::About,
+      ProfileFieldTypes::Employment, ProfileFieldTypes::ProfessionalCategory,
+      ProfileFieldTypes::Competence, ProfileFieldTypes::BankAccount,
+      ProfileFieldTypes::Description, ProfileFieldTypes::Phone,
+      ProfileFieldTypes::NameSurrounding, ProfileFieldTypes::Homepage,
+      ProfileFieldTypes::Date, ProfileFieldTypes::AcademicDegree
+    ]
+  end
+  
+  
+  # Some profile fields may contain values that need review, e.g. when an email could
+  # not be delivered to an email address.
+  #
+  # This is stored as the flag :needs_review.
+  #
+  may_need_review
+   
+end
+