ramaze.ch.oddb.org 1.0.0

data/lib/oddb/util/comparison.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# Util::Comparison -- de.oddb.org -- 13.03.2007 -- hwyss@ywesee.com
+
+require 'delegate'
+
+module ODDB
+  module Util
+    class Comparison < SimpleDelegator
+      attr_reader :difference, :absolute, :factor, 
+        :difference_exfactory, :absolute_exfactory, :factor_exfactory
+      def initialize(package, original)
+        @package = package
+        psize = package.size.to_f
+        pprice = package.price(:public).to_f
+        osize = original.size.to_f
+        oprice = original.price(:public).to_f
+        unless((psize * pprice * osize * oprice) == 0)
+          @factor = psize / osize
+          @absolute = pprice - oprice
+          @difference = ((osize * pprice) / (psize * oprice) - 1) * 100
+        end
+        pprice = package.price(:exfactory).to_f
+        oprice = original.price(:exfactory).to_f
+        unless((psize * pprice * osize * oprice) == 0)
+          @factor_exfactory = psize / osize
+          @absolute_exfactory = pprice - oprice
+          @difference_exfactory = ((osize * pprice) / (psize * oprice) - 1) * 100
+        end
+        super(package)
+      end
+      def is_a?(mod)
+        super || @package.is_a?(mod)
+      end
+    end
+  end
+end

data/lib/oddb/util/exporter.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# Util::Exporter -- de.oddb.org -- 02.10.2007 -- hwyss@ywesee.com
+
+require 'drb'
+
+module ODDB
+  @exporter = DRb::DRbObject.new(nil, @config.server_url_export)
+end

data/lib/oddb/util/feedback.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# Util::Feedback -- de.oddb.org -- 06.12.2007 -- hwyss@ywesee.com
+
+require 'oddb/model'
+
+module ODDB
+  module Util
+class Feedback < Model
+  belongs_to :item
+  attr_accessor :name, :email, :message, :email_public, :item_good_experience,
+    :item_recommended, :item_good_impression, :item_helps, :time
+  def self.newest(count=5)
+    sorted = all.sort_by { |instance| -instance.time.to_f }
+    case count
+    when Integer
+      sorted[0,count]
+    else
+      sorted
+    end
+  end
+end
+  end
+end

data/lib/oddb/util/ipn.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# Util::Ipn -- de.oddb.org -- 29.01.2008 -- hwyss@ywesee.com
+
+require 'oddb/business/invoice'
+require 'oddb/util/mail'
+require 'oddb/util/ydim'
+require 'oddb/util/yus'
+
+module ODDB
+  module Util
+module Ipn
+  def Ipn.process(notification)
+    id = notification.params["invoice"]
+    invoice = Business::Invoice.find_by_id(id) or raise "unknown invoice '#{id}'"
+    invoice.status = notification.status.to_s.downcase
+    if(notification.complete?)
+      Ipn.process_invoice(invoice)
+    else
+      invoice.ipn = notification
+    end
+    invoice.save
+    invoice
+  end
+  def Ipn.process_invoice(invoice)
+    invoice.items.each { |item| Ipn.process_item invoice, item }
+    Ydim.inject(invoice, :payment_received => true)
+    Mail.notify_invoice(invoice)
+  end
+  def Ipn.process_item(invoice, item)
+    case item.type
+    when :poweruser
+      yus_name = invoice.yus_name
+      item.expiry_time = Time.now + (60 * 60 * 24 * item.quantity)
+      Util::Yus.set_preference(yus_name, 'poweruser_duration', item.quantity)
+      Util::Yus.grant(yus_name, 'login', "#{ODDB.config.auth_domain}.PowerUser")
+      Util::Yus.grant(yus_name, 'view', ODDB.config.auth_domain, item.expiry_time)
+    when :export
+      yus_name = invoice.yus_name
+      item.expiry_time = Time.now + (60 * 60 * 24)
+      Util::Yus.grant(yus_name, 'login', "#{ODDB.config.auth_domain}.PowerUser")
+      Util::Yus.grant(yus_name, 'download',
+                      "#{ODDB.config.auth_domain}.#{item.text}",
+                      item.expiry_time)
+    end
+  end
+end
+  end
+end

data/lib/oddb/util/m10l_document.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# M10lDocument -- de.oddb.org -- 13.03.2008 -- hwyss@ywesee.com
+
+require 'oddb/model'
+require 'oddb/util/multilingual'
+
+module ODDB
+  module Util
+    class M10lDocument < Model
+      include M10lMethods
+      connector :canonical
+      attr_reader :previous_sources
+      def initialize(canonical={})
+        super
+        @previous_sources = {}
+      end
+      def add_previous_source(lang, source)
+        sources = (@previous_sources[lang.to_sym] ||= [])
+        sources.push source
+        sources.compact!
+        sources.uniq!
+        sources
+      end
+      def method_missing(meth, *args, &block)
+        case meth.to_s
+        when /^([a-z]{2})=$/
+          lang = $~[1].to_sym
+          if(previous = @canonical[lang])
+            add_previous_source(lang, previous.source)
+          end
+          @canonical.store(lang, args.first)
+        else
+          super(meth, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/oddb/util/mail.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# Util::Mail -- de.oddb.org -- 06.02.2007 -- hwyss@ywesee.com
+
+require 'rmail'
+require 'net/smtp'
+require 'oddb/config'
+require 'oddb/html/util/lookandfeel'
+require 'oddb/util/yus'
+
+module ODDB
+  module Util
+    module Mail
+      def Mail.notify_admins(subject, lines)
+        config = ODDB.config
+        recipients = config.admins
+        mpart = RMail::Message.new
+        header = mpart.header
+        header.to = recipients
+        header.from = config.mail_from
+        header.subject = subject
+        header.date = Time.now
+        header.add('Content-Type', 'text/plain', nil, 
+                   'charset' => config.mail_charset)
+        mpart.body = lines.join("\n")
+        sendmail(mpart, config.smtp_from, recipients)
+      end
+      def Mail.notify_invoice(invoice)
+        config = ODDB.config
+        lnf = Html::Util::LookandfeelStub.new('de')
+        mpart = RMail::Message.new
+        header = mpart.header
+        header.to = recipient = invoice.yus_name
+        header.from = config.mail_invoice_from
+        header.subject = lnf.lookup(:poweruser_mail_subject)
+        header.date = Time.now
+        header.add('Content-Type', 'text/plain', nil, 
+                   'charset' => config.mail_charset)
+        recipients = [recipient].concat config.debug_recipients
+        yus = Util::Yus.get_preferences(recipient, :salutation, :name_last)
+        parts = [
+          lnf.lookup(:poweruser_mail_salut, lnf.lookup(yus[:salutation]), 
+                     yus[:name_last]),
+        ]
+        invoice.items.each { |item|
+          case item.type
+          when :poweruser
+            days = item.quantity
+            duration = (days == 1) \
+                     ? lnf.lookup(:days_one_genitive) \
+                     : lnf.lookup(:days_genitive, days)
+            parts.push lnf.lookup(:poweruser_mail_body)
+            parts.push lnf.lookup(:poweruser_mail_instr,
+                                  duration, lnf._event_url(:login))
+          when :export
+            parts.push lnf.lookup(:download_export_mail_body)
+            parts.push lnf.lookup(:download_export_mail_instr)
+            parts.push lnf._event_url(:collect, [:invoice, invoice.id])
+          end
+        }
+        mpart.body = parts.join("\n\n")
+        sendmail(mpart, config.mail_invoice_smtp, recipients)
+      end
+      def Mail.sendmail(mpart, from, recipients)
+        smtp = Net::SMTP.new(ODDB.config.smtp_server)
+        smtp.start {
+          recipients.each { |recipient|
+            smtp.sendmail(mpart.to_s, from, recipient)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/oddb/util/money.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# Util::Money -- de.oddb.org -- 14.11.2006 -- hwyss@ywesee.com
+
+module ODDB
+  module Util
+class Money
+  attr_reader :credits, :valid_from
+  include Comparable
+  class << self
+    def five
+      @five ||= self.new(5)
+    end
+    def ten
+      @ten ||= self.new(10)
+    end
+  end
+  def initialize(amount)
+    self.amount = amount
+    @valid_from = Time.now
+  end
+  def amount=(amount)
+    @amount = amount.to_f
+    @credits = (@amount * 100).round
+  end
+  def is_for?(type, country)
+    @type == type.to_s.downcase && @country == country.to_s.upcase
+  end
+  def to_f
+    @amount || (@credits.to_f / 100)
+  end
+  def to_s
+    sprintf("%1.2f", to_f)
+  end
+  def valid_from=(time)
+    raise ArgumentError unless time.is_a?(Time)
+    @valid_from = time
+  end
+  def +(other)
+    Money.new((@amount || to_f) + other.to_f)
+  end
+  def -(other)
+    Money.new((@amount || to_f) - other.to_f)
+  end
+  def *(other)
+    Money.new((@amount || to_f) * other.to_f)
+  end
+  def /(other)
+    Money.new((@amount || to_f) / other.to_f)
+  end
+  def <=>(other)
+    case other
+    when Money
+      @credits <=> other.credits
+    else
+      to_f <=> other.to_f
+    end
+  end
+end
+  end
+end

data/lib/oddb/util/multilingual.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# Util::Multilingual -- de.oddb.org -- 04.09.2006 -- hwyss@ywesee.com
+
+module ODDB
+  module Util
+    module M10lMethods
+      include Comparable
+      attr_reader :canonical
+      attr_reader :synonyms
+      def initialize(canonical={})
+        @canonical = canonical
+      end
+      def all
+        @canonical.values
+      end
+      def empty?
+        @canonical.empty?
+      end
+      def method_missing(meth, *args, &block)
+        case meth.to_s
+        when /^[a-z]{2}$/
+          @canonical[meth]
+        when /^([a-z]{2})=$/
+          @canonical.store($~[1].to_sym, args.first)
+        else
+          super(meth, *args, &block)
+        end
+      end
+      def to_s
+        @canonical.values.sort.first.to_s
+      end
+      def ==(other)
+        case other
+        when String
+          @canonical.values.any? { |val| val == other } \
+            || @synonyms.any? { |val| val == other }
+        when M10lDocument
+          @canonical == other.canonical && @synonyms == other.synonyms
+        when M10lMethods
+          @canonical == other.canonical
+        else
+          false
+        end
+      end
+      def <=>(other)
+        all.sort <=> other.all.sort
+      end
+    end
+    class Multilingual
+      include M10lMethods
+      def initialize(canonical={})
+        super
+        @synonyms = []
+      end
+      def add_synonym(synonym)
+        @synonyms.push(synonym).uniq! && synonym
+      end
+      def all
+        terms = super.concat(@synonyms)
+        terms.concat(terms.collect do |term| term.gsub(/[^\w]/, '') end)
+        terms.uniq
+      end
+      def merge(other)
+        @synonyms.concat(other.all).uniq!
+      end
+    end
+  end
+end
+
+require 'oddb/util/m10l_document'

data/lib/oddb/util/quanty.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+require 'oddb/util/quanty/parse'
+require 'oddb/util/quanty/fact'
+require 'oddb/util/quanty/main'

data/lib/oddb/util/quanty/fact.rb

@@ -0,0 +1,229 @@
+# encoding: utf-8
+#
+# quanty/fact.rb
+#
+#   Copyright (c) 2001 Masahiro Tanaka <masa@ir.isas.ac.jp>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 2 or later.
+
+class Quanty
+
+  class Fact < Hash
+    Self = self
+    Parser = Parse.new
+
+    attr_reader :factor
+
+    # Basic units:	Fact.new("m",true) => {"m"=>1}
+    # Derivative units:	Fact.new("km") => 1000*{"m"=>1}
+    def initialize(key=nil,base=false)
+      self.default = 0.0
+      @factor = 1.0
+      case key
+      when Numeric
+	@factor = key
+      when String
+	if base
+	  store(key, 1.0)
+	else
+	  decomp(key)
+	end
+      when Self
+	replace(key)
+      end
+    end
+
+    def []=(key,val)
+      if val == 0
+	delete(key)
+      else
+	super(key,val)
+      end
+    end
+
+    def replace(other)
+      @factor = other.factor
+      super(other)
+    end
+
+    def dup
+      Fact.new(self)
+    end
+
+    def find_prefix(a,n)
+      Prefix.each{ |key,factor|
+	if /^#{key}-?/u =~ a && (unit = List[b=$']) && b.size>n
+	  #p [a,b,factor]
+	  return Fact.new(b).fac!(factor)
+	end
+      }
+      nil
+    end
+
+    def decomp(a)
+      if /^([µA-Za-z_]+([A-Za-z_0-9-]+[A-Za-z_])?)$|^[$%'"]'?$/ou =~ a
+      #if /^[A-Za-z_0-9$%-]+$/o =~ a
+	unit = List[a] || find_prefix(a,0) ||
+	  if a.size>3 && /chs$/ou !~ a && /(.*[a-rt-y])s$/ou =~ a
+	    b = $1
+	    List[b] || find_prefix(b,2) ||
+	      if a.size>4 && /(.*s|.*z|.*ch)es$/ou =~ a
+		b = $1
+		List[b] || find_prefix(b,2)
+	      end
+	  end
+      else
+	unit = Parser.parse(a)
+      end
+      unless unit
+	raise "`%s': unknown unit"%a 
+      end
+      @factor *= factor if factor
+      mul!(unit)
+    end
+
+    def mul!(other)
+      raise unless other.kind_of?(Fact)
+      other.each{ |key,val| self[key] += val }
+      delete_if{ |key,val| val == 0 }
+      @factor *= other.factor
+      self
+    end
+
+    def * (other)
+      dup.mul!(other)
+    end
+
+    def div!(other)
+      raise unless other.kind_of?(Fact)
+      other.each{ |key,val| self[key] -= val }
+      delete_if{ |key,val| val == 0 }
+      @factor /= other.factor
+      self
+    end
+
+    def / (other)
+      dup.div!(other)
+    end
+
+    def pow!(other)
+      raise unless other.kind_of?(Numeric)
+      each{ |key,val| self[key] = other*val }
+      @factor **= other
+      self
+    end
+
+    def ** (other)
+      dup.pow!(other)
+    end
+  
+    def fac!(other)
+      raise unless other.kind_of?(Numeric)
+      @factor *= other
+      self
+    end
+
+    def inspect
+      @factor.to_s+"*"+super
+    end
+
+    def to_s
+      a = []
+      each{|k,v|
+	if v != 1
+	  v  = v.to_i if v%1 == 0
+	  k += v.to_s
+	end
+	a.push k
+      }
+      @factor.to_s+" "+a.join(" ")
+    end
+
+    def null?
+      each_value{ |val| return false if val != 0 }
+      true
+    end
+
+    alias __equal__ :==
+
+    def ==(other)
+      if other.kind_of?(Numeric)
+	null? && @factor==other
+      else
+	__equal__(other) && @factor==other.factor
+      end
+    end
+
+    # check only dimension
+    def ===(other)
+      if other.kind_of?(Numeric)
+	null?
+      else
+	__equal__(other)
+      end
+    end
+
+    def to_f
+      raise inspect + ": not null unit" unless null?
+      @factor
+    end
+
+    class << self
+      def mkdump filename
+	Prefix.clear
+	List.clear
+	#s = open("units.succ","w")
+	#f = open("units.fail","w")
+	open("units.dat","r").readlines.each do |str|
+	  if /^([µA-Za-z_0-9%$"'-]+)\s+([^#]+)/u =~ str
+	    name,repr = $1,$2.strip
+	    # conversion due to the different rule from GNU units:
+	    #   A / B C => A / (B C)
+	    if /\//u =~ repr #/
+	      pre,suf = $`,$'.strip
+	      if /\s/u =~ suf
+		repr = pre + ' / (' + suf + ')'
+	      end
+	    end
+	    if repr=="!"
+	      List[name] = Fact.new(name,true).freeze
+	    elsif /-$/u  =~ name
+	      Prefix[name[0..-2]] = Prefix[repr] || (List[repr] || repr).to_f
+	    else
+	      #p [name,repr]
+	      List[name] = Fact.new(repr).freeze
+	    end
+	    #s.print str
+	    #rescue
+	    #f.print str
+	  end
+	end
+	#Prefix.each{|key,val| p [key,val]}
+	#List.each{|key,val| p [key,val]}
+	Marshal.dump( [Prefix, List], open(filename,"w") )
+      end
+    end
+
+  end # class Fact
+
+
+  ### Loading unit data ###
+=begin
+  fn = nil
+  $:.each{ |dir|
+    fn = dir + "/quanty/units.dump"
+    break if FileTest.exist?( fn )
+    fn = nil
+  }
+=end
+	fn = File.expand_path('units.dump', File.dirname(__FILE__))
+	fn = nil unless FileTest.exist?( fn )
+  if fn
+    Prefix, List = Marshal.load(open(fn,"r"))
+  else
+    Prefix, List = {},{}
+  end
+
+end # class Quanty