alchemy_crm 2.0.0

data/app/models/alchemy/essence_element_teaser.rb

@@ -0,0 +1,19 @@
+module Alchemy
+	class EssenceElementTeaser < ActiveRecord::Base
+
+		acts_as_essence(
+			:ingredient_column => :url,
+			:preview_text_method => :url
+		)
+
+		# Saves the content from params
+		def save_ingredient(params, options = {})
+			return true if params.blank?
+			self.url = params["url"]
+			self.title = params["title"]
+			self.text = params["text"]
+			self.save!
+		end
+
+	end
+end

data/app/models/alchemy_crm/contact.rb

@@ -0,0 +1,264 @@
+# encoding: UTF-8
+
+module AlchemyCrm
+	class Contact < ActiveRecord::Base
+
+		acts_as_taggable
+
+		attr_accessible(
+			:salutation,
+			:title,
+			:firstname,
+			:lastname,
+			:email,
+			:phone,
+			:mobile,
+			:address,
+			:zip,
+			:city,
+			:organisation,
+			:country,
+			:subscriptions_attributes
+		)
+
+		attr_accessible(
+			:salutation,
+			:title,
+			:firstname,
+			:lastname,
+			:email,
+			:phone,
+			:mobile,
+			:address,
+			:zip,
+			:city,
+			:organisation,
+			:country,
+			:subscriptions_attributes,
+			:verified,
+			:disabled,
+			:tag_list,
+			:as => :admin
+		)
+
+		has_many :subscriptions, :dependent => :destroy
+		has_many :newsletters, :through => :subscriptions, :uniq => true
+		has_many :recipients
+
+		attr_accessor :skip_validation
+
+		accepts_nested_attributes_for :subscriptions, :allow_destroy => true
+
+		validates_presence_of :salutation, :unless => proc { skip_validation }
+		validates_presence_of :firstname, :unless => proc { skip_validation }
+		validates_presence_of :lastname
+		validates_presence_of :email
+		validates_uniqueness_of :email
+		validates_format_of :email, :with => ::Authlogic::Regex.email, :if => proc { errors[:email].blank? }
+
+		before_save :update_sha1, :if => proc { email_sha1.blank? || email_changed? }
+
+		scope :verified, where(:verified => true)
+		scope :disabled, where(:disabled => true)
+		scope :enabled, where(:disabled => false)
+		scope :available, verified.enabled
+
+		COLUMN_NAMES = [
+			[::I18n.t(:title, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Title'), "title"],
+			[::I18n.t(:salutation, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Salutation'), "salutation"],
+			[::I18n.t(:firstname, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Firstname'), "firstname"],
+			[::I18n.t(:lastname, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Lastname'), "lastname"],
+			[::I18n.t(:address, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Address'), "address"],
+			[::I18n.t(:zip, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Zipcode'), "zip"],
+			[::I18n.t(:city, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'City'), "city"],
+			[::I18n.t(:country, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Country'), "country"],
+			[::I18n.t(:organisation, :scope => 'activerecord.attributes.alchemy_crm/contact', :default => 'Organisation'), "organisation"]
+		]
+
+		INTERPOLATION_NAME_METHODS = %w(fullname name_with_title firstname lastname name email)
+
+		def disable!
+			update_attributes({
+				:verified => false,
+				:disabled => true
+			}, :as => :admin)
+			subscriptions.destroy_all
+		end
+
+		# Returns a full name
+		# Salutation + Title + Firstname + Lastname
+		def fullname
+			if lastname.present? || firstname.present?
+				"#{translated_salutation} #{name_with_title}".squeeze(" ")
+			else
+				name
+			end
+		end
+
+		# Translated salutation
+		# 
+		# Translate the saluations in your +config/LOCALE.yml+
+		# 
+		#   alchemy_crm:
+		#     salutations:
+		#       mr: 
+		#       ms: 
+		# 
+		def translated_salutation
+			::I18n.t(salutation, :scope => [:alchemy_crm, :salutations], :default => salutation.to_s.capitalize)
+		end
+
+		# Returns the name and title
+		# Title + Firstname + Lastname
+		def name_with_title
+			"#{title} #{name}".squeeze(" ")
+		end
+
+		# Returns the name ot email, if no name is present
+		# Firstname + Lastname, or email
+		def name
+			if lastname.present? || firstname.present?
+				"#{firstname} #{lastname}".squeeze(" ")
+			else
+				email
+			end
+		end
+
+		# Uses the +config['name_interpolation_method']+ to return the value for emails and forms %{name} interpolations.
+		def interpolation_name_value
+			name_interpolation_method = Config.get(:name_interpolation_method)
+			if name_interpolation_method.present? && INTERPOLATION_NAME_METHODS.include?(name_interpolation_method.to_s) && self.respond_to?(name_interpolation_method.to_sym)
+				self.send(name_interpolation_method.to_sym)
+			else
+				fullname
+			end
+		end
+
+		def self.fake
+			fake = new(
+				:salutation => nil,
+				:title => ::I18n.t(:title, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'Dr.'),
+				:firstname => ::I18n.t(:firstname, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'Jon'),
+				:lastname => ::I18n.t(:lastname, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'Doe'),
+				:email => ::I18n.t(:email, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'jon@doe.com'),
+				:phone => ::I18n.t(:phone, :scope => 'alchemy_crm.fake_contact_attributes', :default => '1-1234567'),
+				:mobile => ::I18n.t(:mobile, :scope => 'alchemy_crm.fake_contact_attributes', :default => '123-456789'),
+				:address => ::I18n.t(:address, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'Street 1'),
+				:zip => ::I18n.t(:zip, :scope => 'alchemy_crm.fake_contact_attributes', :default => '10000'),
+				:city => ::I18n.t(:city, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'City'),
+				:organisation => ::I18n.t(:organisation, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'Company inc.'),
+				:country => ::I18n.t(:country, :scope => 'alchemy_crm.fake_contact_attributes', :default => 'US')
+			)
+			fake.readonly!
+			fake
+		end
+
+		def self.replace_tag(old_tag, new_tag)
+			self.tagged_with(old_tag).each do |contact|
+				contact.tags.delete(old_tag)
+				contact.tags << new_tag
+				contact.save
+			end
+		end
+
+		def self.find_by_query(query, options, paginate)
+			column_names = Contact.public_column_names
+			search_string = (column_names.join(" LIKE '%#{query}%' OR ") + " LIKE '%#{query}%'")
+			contacts = where(search_string)
+			if paginate
+				contacts.paginate(options)
+			else
+				contacts
+			end
+		end
+
+		#TODO: Zu den selbstgewählten Mailingformaten müssten noch alle durch den Backend User gewählten Formate mit angezeigt werden, oder?
+		def all_newsletters
+			self.newsletters
+		end
+
+		def self.public_column_names
+			Contact.column_names - ["created_at", "updated_at", "email_salt", "verified", "email_sha1", "id"]
+		end
+
+		def self.filterable_column_names
+			COLUMN_NAMES
+		end
+
+		def self.find_or_create(data)
+			if (contact = Contact.find_by_email(data[:email])).nil?
+				contact = Contact.create(data)
+			end
+			contact
+		end
+
+		def all_subscriptions_verified?
+			self.subscriptions.inject(true){|acc, s| acc = s.verified? && acc; acc}
+		end
+
+		def self.new_from_recipient(recipient)
+			raise "No recipient found!" if recipient.nil?
+			contact = new(:email => recipient.email, :lastname => recipient.email)
+			contact.readonly!
+			contact
+		end
+
+		def self.new_from_vcard(vcard, verified)
+			raise "No vcard found!" if vcard.nil?
+			raise ::I18n.t(:imported_contacts_not_verified, :scope => :alchemy_crm) if !verified
+			contacts = []
+			::Vpim::Vcard.decode(vcard).each do |card|
+				remapped_attributes = {
+					:organisation => card.org.blank? ? nil : card.org.first,
+					:lastname => card.name.blank? ? nil : card.name.family,
+					:firstname => card.name.blank? ? nil : card.name.given,
+					:title => card.name.blank? ? nil : card.name.prefix,
+					:address => card.address.blank? ? nil : card.address.street,
+					:city => card.address.blank? ? nil : card.address.locality,
+					:country => card.address.blank? ? nil : card.address.country,
+					:zip => card.address.blank? ? nil : card.address.postalcode,
+					:email => card.email.to_s,
+					:phone => card.telephone ? card.telephone.location.include?("cell") ? nil : card.telephone.to_s : nil,
+					:mobile => card.telephones.detect { |t| t.location.include?("cell") }.to_s,
+					:verified => true
+				}
+				contact = Contact.new(remapped_attributes, :as => :admin)
+				contact.skip_validation = true
+				contact.save
+				contacts << contact
+			end
+			contacts
+		end
+
+		def to_vcard
+			card = Vpim::Vcard::Maker.make2 do |maker|
+				maker.add_name do |name|
+					name.prefix = title unless title.blank?
+					name.given = firstname unless firstname.blank?
+					name.family = lastname unless lastname.blank?
+				end
+				maker.add_tel(phone) { |t| t.location = 'work' } unless phone.blank?
+				maker.add_tel(mobile) { |t| t.location = 'cell' } unless mobile.blank?
+				maker.add_email(email) { |e| e.location = 'work' } unless email.blank?
+				maker.add_addr do |addr|
+					addr.street = address
+					addr.postalcode = zip
+					addr.locality = city
+					addr.country = country
+				end
+				maker.org = organisation
+			end
+			vcf = File.new(Rails.root.to_s + "/tmp/#{fullname}.vcf", "w")
+			vcf.write(card.encode)
+			vcf.close
+		end
+
+	private
+
+		def update_sha1
+			salt = email_salt || [Array.new(6){rand(256).chr}.join].pack("m")[0..7]
+			self.email_salt, self.email_sha1 = salt, Digest::SHA1.hexdigest(email + salt)
+		end
+
+	end
+end

data/app/models/alchemy_crm/contact_group.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+module AlchemyCrm
+	class ContactGroup < ActiveRecord::Base
+
+		acts_as_taggable_on :contact_tags
+
+		has_many :filters, :dependent => :destroy, :class_name => "AlchemyCrm::ContactGroupFilter"
+
+		validates_presence_of :name
+
+		accepts_nested_attributes_for :filters, :allow_destroy => true
+
+		def contacts
+			Contact.tagged_with(self.contact_tags, :any => true).where(filters_sql_string)
+		end
+
+		def filters_sql_string
+			filters.map(&:sql_string).join(' AND ')
+		end
+
+		def humanized_name
+			"#{self.name} (#{self.contacts.length})"
+		end
+
+	end
+end

data/app/models/alchemy_crm/contact_group_filter.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+module AlchemyCrm
+	class ContactGroupFilter < ActiveRecord::Base
+
+		belongs_to :contact_group
+
+		OPERATORS = [
+			[::I18n.t(:like, :scope => 'alchemy_crm.contact_group_filter_operators', :default => 'Contains'), "LIKE"],
+			[::I18n.t(:not_like, :scope => 'alchemy_crm.contact_group_filter_operators', :default => 'Contains not'), "NOT LIKE"],
+			[::I18n.t(:equals, :scope => 'alchemy_crm.contact_group_filter_operators', :default => 'Equals'), "="],
+			[::I18n.t(:equals_not, :scope => 'alchemy_crm.contact_group_filter_operators', :default => 'Equals not'), "!="]
+		]
+
+		def sql_string
+			return "" if column.blank? || operator.blank? || prepared_value.blank?
+			"`#{Contact.table_name}`.`#{column}` #{operator} '#{prepared_value}'"
+		end
+
+	private
+
+		def prepared_value
+			operator =~ /LIKE/ ? "%#{value}%" : "#{value}"
+		end
+
+	end
+end

data/app/models/alchemy_crm/delivery.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+module AlchemyCrm
+	class Delivery < ActiveRecord::Base
+
+		attr_accessor :chunk_delay
+
+		belongs_to :mailing
+		has_many :recipients, :dependent => :destroy
+
+		after_create :recipients_from_mailing_contacts
+
+		scope :delivered, where("`alchemy_crm_deliveries`.`delivered_at` IS NOT NULL")
+		scope :pending, where("`alchemy_crm_deliveries`.`delivered_at` IS NULL")
+
+		def delivered?
+			!self.delivered_at.nil?
+		end
+
+		# Sending mails in chunks.
+		def send_chunks(options={})
+			raise "No Mailing Given" if mailing.blank?
+			@chunk_delay = 0
+			recipients.each_slice(self.class.settings(:send_mails_in_chunks_of)) do |recipients_chunk|
+				send_mail_chunk(recipients_chunk, options)
+				@chunk_delay += 1
+			end
+			update_attribute(:delivered_at, Time.now)
+		end
+		handle_asynchronously :send_chunks, :run_at => proc { |m| m.deliver_at || Time.now }
+
+		# Send the mail chunk via delayed_job and waiting some time before next is enqueued
+		def send_mail_chunk(recipients_chunk, options)
+			recipients_chunk.each do |recipient|
+				mail = MailingsMailer.build(mailing, recipient, options).deliver
+				recipient.update_attribute(:message_id, mail.message_id)
+			end
+		end
+		handle_asynchronously :send_mail_chunk, :run_at => proc { |m| (m.chunk_delay * m.class.settings(:send_mail_chunks_every)).minutes.from_now }
+
+		def self.settings(name)
+			AlchemyCrm::Config.get(name)
+		end
+
+	private
+
+		def recipients_from_mailing_contacts
+			raise "No Mailing Given" if mailing.blank?
+			mailing.contacts_not_having_email_yet.each do |contact|
+				recipients << Recipient.create!(
+					:email => contact.email,
+					:contact => contact
+				)
+			end
+		end
+
+	end
+end

data/app/models/alchemy_crm/element_extension.rb

@@ -0,0 +1,28 @@
+# Extending Alchemys Element model
+Alchemy::Element.class_eval do
+
+	def update_from_element(source, url)
+		self.contents.each do |content|
+			source_content = source.contents.find_by_name(content.name)
+			if !source_content.blank? && source_content.essence_type == content.essence_type
+				case content.essence_type
+					when "Alchemy::EssenceText"
+					content.essence.body = source_content.essence.body
+					when "Alchemy::EssenceRichtext"
+					content.essence.body = source_content.essence.body
+					when "Alchemy::EssencePicture"
+					content.essence.picture_id = source_content.essence.picture_id
+					when "Alchemy::EssenceAttachment"
+					content.essence.attachment_id = source_content.essence.attachment_id
+				end
+				content.essence.save
+			end
+		end
+		teaser = self.contents.where(:essence_type => "Alchemy::EssenceElementTeaser").first
+		if !teaser.essence.blank?
+			teaser.essence.url = url
+			teaser.essence.save
+		end
+	end
+
+end

data/app/models/alchemy_crm/mailing.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+module AlchemyCrm
+	class Mailing < ActiveRecord::Base
+
+		MAILING_PAGE_LAYOUT_PREFIX = "newsletter_layout_"
+
+		belongs_to :page, :dependent => :destroy, :class_name => 'Alchemy::Page'
+		has_many :deliveries, :dependent => :destroy
+		has_many :recipients, :through => :deliveries
+		belongs_to :newsletter
+
+		validates_presence_of :name
+		validates_presence_of :newsletter_id, :on => :create
+
+		before_create :set_sha1
+		after_create :create_page
+
+		# Returns all contacts found via newsletter.
+		def newsletter_contacts
+			return [] if newsletter.blank?
+			newsletter.contacts
+		end
+
+		# Returns all contacts found via newsletter contacts and additional email addresses.
+		def contacts
+			(newsletter_contacts + contacts_from_additional_email_addresses).uniq
+		end
+
+		def contacts_count
+			return 0 if contacts.blank?
+			contacts.count
+		end
+
+		def contacts_not_having_email_yet
+			return contacts if recipients.empty?
+			contacts.select { |c| !recipients.collect(&:email).include?(c.email) }
+		end
+
+		# Returns a list of all email addresses for contacts that have not got any email yet.
+		def emails
+			contacts_not_having_email_yet.collect(&:email)
+		end
+
+		# Return a list of email addresses from additional_email_addresses field.
+		def additional_emails
+			return [] if additional_email_addresses.blank?
+			additional_email_addresses.gsub(/\s/,'').split(',').uniq
+		end
+
+		# Returns a list of contacts found or initialized by email address from additional_email_addresses field.
+		def contacts_from_additional_email_addresses
+			additional_emails.collect{ |email| Contact.find_or_initialize_by_email(:email => email) }
+		end
+
+		# Makes a copy of another mailing.
+		def self.copy(id)
+			source = self.find(id)
+			new(source.attributes.merge(
+				"name" => "#{source.name} (#{::I18n.t(:copy, :scope => :alchemy_crm, :default => 'Copy')})"
+			).except("id", "updated_at", "created_at", "sha1", "salt", "page_id"))
+		end
+
+		def next_pending_delivery
+			deliveries.pending.first
+		end
+
+	private
+
+		def create_page
+			mailing_root = Alchemy::Page.find_by_name('Alchemy CRM Rootpage')
+			raise "Alchemy CRM Rootpage not found. Did you seed the database?" if mailing_root.blank?
+			mailing_page = Alchemy::Page.new(
+				:name => "Mailing #{self.name}",
+				:sitemap => false,
+				:page_layout => newsletter.layout,
+				:language => Alchemy::Language.get_default,
+				:parent_id => mailing_root.id
+			)
+			if mailing_page.save
+				self.page = mailing_page
+				save
+			else
+				raise "Error while creating Mailingpage: #{mailing_page.errors.full_messages}"
+			end
+		end
+
+		def set_sha1
+			self.salt = [Array.new(6){rand(256).chr}.join].pack("m")[0..7]
+			self.sha1 = Digest::SHA1.hexdigest(Time.now.to_i.to_s + salt)
+		end
+
+	end
+end