ticket_sales 0.1.1

data/.gitignore

@@ -0,0 +1 @@
+*.db

data/README.md

@@ -0,0 +1,2 @@
+ticket_sales
+============

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/ticket_sales/**/*.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/lib/ticket_sales.rb

@@ -0,0 +1,18 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+require 'ticket_sales/ticket/route'
+require 'ticket_sales/ticket/ticket'
+require 'ticket_sales/ticket/travel_time'
+require 'ticket_sales/criteria'
+require 'ticket_sales/promotion'
+require 'ticket_sales/ticket_list'
+require 'ticket_sales/ticket_center'
+require 'ticket_sales/user'
+
+require 'dm-core'
+require 'dm-validations'
+require 'dm-timestamps'
+require 'dm-migrations'
+require 'ticket_sales/data_models/data_models'
+require 'ticket_sales/data_models/repository'

data/lib/ticket_sales/criteria.rb

@@ -0,0 +1,63 @@
+module TicketSales
+  module Criteria
+    class << self
+      def from(location)
+        Criterion.new { |ticket| ticket.from == location }
+      end
+
+      def to(location)
+        Criterion.new { |ticket| ticket.to == location }
+      end
+
+      def price_from(amount)
+        Criterion.new { |ticket| amount <= ticket.price }
+      end
+
+      def price_to(amount)
+        Criterion.new { |ticket| ticket.price <= amount }
+      end
+
+      def departs_before(time)
+        Criterion.new { |ticket| ticket.departure_time < time }
+      end
+
+      def departs_after(time)
+        Criterion.new { |ticket| time < ticket.departure_time }
+      end
+
+      def arrives_before(time)
+        Criterion.new { |ticket| ticket.arrival_time < time }
+      end
+
+      def arrives_after(time)
+        Criterion.new { |ticket| time < ticket.arrival_time }
+      end
+
+      def feature(string)
+        Criterion.new { |ticket| /#{string}/ === ticket.features }
+      end
+    end
+
+    class Criterion
+      def initialize(&condition)
+        @condition = condition
+      end
+
+      def met_by?(ticket)
+        @condition.call(ticket)
+      end
+
+      def &(other)
+        Criterion.new { |ticket| met_by? ticket and other.met_by? ticket }
+      end
+
+      def |(other)
+        Criterion.new { |ticket| met_by? ticket or other.met_by? ticket }
+      end
+
+      def !
+        Criterion.new { |ticket| !met_by? ticket }
+      end
+    end
+  end
+end

data/lib/ticket_sales/data_models/data_models.rb

@@ -0,0 +1,38 @@
+module DataModels
+  DataMapper.setup :default, "sqlite://#{Dir.pwd}/database.db"
+
+  class Ticket
+    include DataMapper::Resource
+
+    property :id,             Serial, serial: true
+    property :from,           String
+    property :to,             String
+    property :distance,       Float
+    property :departure_time, DateTime
+    property :arrival_time,   DateTime
+    property :price,          Decimal
+    property :features,       String
+
+    has 1,     :property
+    belongs_to :ticket_center
+  end
+
+  class Property
+    include DataMapper::Resource
+
+    property :id,              Serial, serial: true
+    property :count,           Integer
+    property :promotion_name,  String
+    property :promotion_value, Decimal
+
+    belongs_to :ticket
+  end
+
+  class TicketCenter
+    include DataMapper::Resource
+
+    property :id, Serial, serial: true
+
+    has n, :tickets
+  end
+end

data/lib/ticket_sales/data_models/repository.rb

@@ -0,0 +1,72 @@
+module DataModels
+  module Repository
+    class << self
+      include TicketSales::Promotion
+
+      def persist(ticket_center)
+        data_tickets = ticket_center.properties.map { |ticket, property| ticket_data ticket, property }
+        TicketCenter.create tickets: data_tickets
+      end
+
+      def find(id)
+        TicketCenter.get(id)
+      end
+
+      def ticket_center_from(ticket_center_data)
+        result = TicketSales::TicketCenter.new
+
+        tickets = ticket_center_data.tickets.map { |ticket_data| ticket_from ticket_data }
+        properties = ticket_center_data.tickets.map { |ticket_data| property_from ticket_data }
+
+        tickets.zip(properties).each do |ticket, property|
+          result.add ticket, property.count, property.promotion
+        end
+
+        result
+      end
+
+      private
+
+      def ticket_data(ticket, property)
+        Ticket.new from: ticket.from, to: ticket.to, distance: ticket.distance,
+          departure_time: ticket.departure_time, arrival_time: ticket.arrival_time,
+          price: ticket.price, features: ticket.features, property: property_data_from(property)
+      end
+
+      def ticket_from(ticket_data)
+        TicketSales::Ticket.build(ticket_data.from, ticket_data.to, ticket_data.distance,
+          ticket_data.departure_time.to_time, ticket_data.arrival_time.to_time,
+          ticket_data.price, ticket_data.features)
+      end
+
+      def property_from(ticket_data)
+        property_data = ticket_data.property
+        TicketSales::TicketProperty.new property_data.count,
+          TicketSales::Promotion.build(property_data.promotion_name.to_sym => property_data.promotion_value)
+      end
+
+      def property_data_from(property)
+        promotion_type = type_of property.promotion
+
+        if promotion_type == :percent
+          Property.new count: property.count, promotion_name: :percent,
+            promotion_value: property.promotion.percent
+        else
+          Property.new count: property.count, promotion_name: promotion_type,
+            promotion_value: property.promotion.amount
+        end
+      end
+
+      def type_of(promotion)
+        case promotion
+          when EveryHour then :hour
+          when EveryStop then :stop
+          when EveryHundredthKilometer then :hundred_kilometers
+          when PercentOff then :percent
+          when AmountOff then :amount
+          else :no_promotion
+        end
+      end
+    end
+  end
+end

data/lib/ticket_sales/promotion.rb

@@ -0,0 +1,64 @@
+module TicketSales
+  module Promotion
+    def self.build(options = {})
+      type, value = *options.first
+
+      case type
+        when :percent then PercentOff.new value
+        when :amount then AmountOff.new value
+        when :hundred_kilometers then EveryHundredthKilometer.new value
+        when :stop then EveryStop.new value
+        when :hour then EveryHour.new value
+        else NoPromotion.new
+      end
+    end
+
+    class PercentOff
+      attr_reader :percent
+
+      def initialize(percent)
+        @percent = percent
+      end
+
+      def discount(ticket)
+        (@percent / '100'.to_d) * ticket.price
+      end
+    end
+
+    class AmountOff
+      attr_reader :amount
+
+      def initialize(amount)
+        @amount = amount.to_d
+      end
+
+      def discount(ticket)
+        [@amount, ticket.price].min
+      end
+    end
+
+    class EveryHundredthKilometer < AmountOff
+      def discount(ticket)
+        [@amount * (ticket.distance / 100), ticket.price].min
+      end
+    end
+
+    class EveryStop < AmountOff
+      def discount(ticket)
+        [@amount * ticket.route.stops.size, ticket.price].min
+      end
+    end
+
+    class EveryHour < AmountOff
+      def discount(ticket)
+        [@amount * (ticket.travel_length.to_i), ticket.price].min
+      end
+    end
+
+    class NoPromotion
+      def discount(ticket)
+        '0'.to_d
+      end
+    end
+  end
+end

data/lib/ticket_sales/ticket/route.rb

@@ -0,0 +1,18 @@
+module TicketSales
+  class Route
+    attr_reader :from, :to, :distance, :stops
+
+    def initialize(from, to, distance, stops = [])
+      @distance = distance
+      @from = from
+      @to = to
+      @stops = stops
+    end
+
+    def combine(route)
+      raise 'Incorrect route' if @to != route.from
+      stops = @stops + [@to] + route.stops
+      Route.new @from, route.to, @distance + route.distance, stops
+    end
+  end
+end

data/lib/ticket_sales/ticket/ticket.rb

@@ -0,0 +1,68 @@
+module TicketSales
+  class Ticket
+    attr_reader :price, :features, :route, :time, :combined_by
+
+    def self.build(from, to, distance, departure, arrival, price, features)
+      route = Route.new from, to, distance
+      time = TravelTime.new departure, arrival
+
+      new route, price, features, time
+    end
+
+    def initialize(route, price, features, time, combined_by = [])
+      @time = time
+      @route = route
+      @price = price
+      @features = features
+      @combined_by = combined_by
+    end
+
+    def from
+      @route.from
+    end
+
+    def to
+      @route.to
+    end
+
+    def distance
+      @route.distance
+    end
+
+    def departure_time
+      @time.departure
+    end
+
+    def arrival_time
+      @time.arrival
+    end
+
+    def travel_length
+      @time.length
+    end
+
+    def combined?
+      !@combined_by.empty?
+    end
+
+    def combine(other)
+      features = @features + ', ' + other.features
+      Ticket.new route.combine(other.route), price + other.price, features,
+        time.combine(other.time), [self, other]
+    end
+
+    def ==(other)
+      from == other.from and to == other.to and
+        route.stops == other.route.stops and
+        time == other.time and price == other.price and
+        features == other.features
+    end
+
+    alias eql? ==
+
+    def hash
+      [@route.from, @route.to, @time.arrival, @time.departure,
+        @price, @features, @combined_by].hash
+    end
+  end
+end

data/lib/ticket_sales/ticket/travel_time.rb

@@ -0,0 +1,49 @@
+module TicketSales
+  class TimeInterval
+    attr_reader :start_time, :end_time
+
+    def initialize(start_time, end_time)
+      @start_time = start_time
+      @end_time = end_time
+    end
+
+    def length
+      (@end_time - @start_time).to_d / 3600
+    end
+
+    def ==(other)
+      start_time == other.start_time and
+        end_time == other.end_time
+    end
+  end
+
+  class TravelTime < TimeInterval
+    attr_reader :pauses
+
+    def initialize(departure, arrival, pauses = [])
+      super departure, arrival
+      @pauses = pauses
+    end
+
+    def departure
+      @start_time
+    end
+
+    def arrival
+      @end_time
+    end
+
+    def pauses_length
+      pauses.map(&:length).inject('0'.to_d, &:+)
+    end
+
+    def combine(other)
+      new_pause = TimeInterval.new arrival, other.departure
+      TravelTime.new departure, other.arrival, pauses + [new_pause] + other.pauses
+    end
+
+    def ==(other)
+      super and pauses == other.pauses
+    end
+  end
+end

data/lib/ticket_sales/ticket_center.rb

@@ -0,0 +1,77 @@
+module TicketSales
+  class TicketProperty
+    attr_reader :promotion, :count, :bought_count
+
+    def initialize(count, promotion)
+      @count = count
+      @promotion = promotion
+      @bought_count = 0
+    end
+
+    def decrease_count(number)
+      @count -= number
+      @bought_count += number
+    end
+  end
+
+  class UnavailableTicket < RuntimeError
+  end
+
+  class TicketCenter
+    attr_reader :tickets, :properties
+
+    def initialize
+      @tickets = TicketList.new
+      @properties = {}
+    end
+
+    def add(ticket, count = 1, promotion = Promotion::NoPromotion.new)
+      @tickets.add ticket
+      @properties[ticket] = TicketProperty.new count, promotion
+    end
+
+    def available?(ticket, count = 1)
+      @tickets.include? ticket and enough_tickets? ticket, count
+    end
+
+    def sell(user, ticket, count = 1)
+      raise UnavailableTicket.new unless available? ticket, count
+
+      price = get_price ticket
+      if user.can_pay? count * price
+        count.times { user.buy ticket, price }
+        decrease_count ticket, count
+      end
+    end
+
+    def most_bought_tickets
+      @properties.sort_by { |ticket, property| -property.bought_count }.map(&:first)
+    end
+
+    private
+
+    def get_price(ticket)
+      if ticket.combined?
+        ticket.combined_by.map { |current| get_price current }.inject(&:+)
+      else
+        ticket.price - @properties[ticket].promotion.discount(ticket)
+      end
+    end
+
+    def enough_tickets?(ticket, count)
+      if ticket.combined?
+        ticket.combined_by.all? { |current| enough_tickets? current, count }
+      else
+        @properties[ticket].count >= count
+      end
+    end
+
+    def decrease_count(ticket, count)
+      if ticket.combined?
+        ticket.combined_by.each { |current| decrease_count current, count }
+      else
+        @properties[ticket].decrease_count count
+      end
+    end
+  end
+end