polish_invoicer 0.0.1

data/lib/polish_invoicer/vat.rb

@@ -0,0 +1,36 @@
+module PolishInvoicer
+  class Vat
+    def self.rates
+      [23, 8, 5, 0, -1] # -1 oznacza zwolniony z VAT
+    end
+
+    def self.valid?(rate)
+      rates.include?(rate)
+    end
+
+    # Czy stawka VAT to "zwolniony"?
+    def self.zw?(rate)
+      rate == -1
+    end
+
+    def self.to_s(rate)
+      hash.invert[rate]
+    end
+
+    # Potrzebne do obliczeń netto/vat/brutto
+    def self.to_i(rate)
+      (rate != -1) ? rate : 0
+    end
+
+    protected
+      def self.hash
+        h = {}
+        rates.each do |r|
+          name = "#{r}%"
+          name = 'zw.' if r == -1
+          h[name] = r
+        end
+        h
+      end
+  end
+end

data/lib/polish_invoicer/version.rb

@@ -0,0 +1,3 @@
+module PolishInvoicer
+  VERSION = "0.0.1"
+end

data/lib/polish_invoicer/writer.rb

@@ -0,0 +1,34 @@
+module PolishInvoicer
+  class Writer
+    attr_accessor :invoice, :template_path
+    attr_accessor :logger, :wkhtmltopdf_command
+
+    def initialize(invoice)
+      @invoice = invoice
+      default_template_path = File.expand_path('../../../tpl/invoice.slim', __FILE__)
+      @template_path = @invoice.template_path || default_template_path
+      @logger = @invoice.logger
+      @wkhtmltopdf_command = @invoice.wkhtmltopdf_command
+    end
+
+    def save_to_html(path)
+      create_writer
+      @writer.save_to_html(path)
+    end
+
+    def save_to_pdf(path)
+      create_writer
+      @writer.save_to_pdf(path)
+    end
+
+    protected
+      def create_writer
+        @writer = Slim2pdf::Writer.new(template_path)
+        @writer.wkhtmltopdf_command = wkhtmltopdf_command
+        @writer.logger = logger
+        data = @invoice.to_hash
+        @writer.data = data
+        @writer.footer_text = data[:footer]
+      end
+  end
+end

data/polish_invoicer.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'polish_invoicer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "polish_invoicer"
+  spec.version       = PolishInvoicer::VERSION
+  spec.authors       = ["Piotr Macuk"]
+  spec.email         = ["piotr@macuk.pl"]
+  spec.description   = %q{Creates polish invoices and proforms as HTML or PDF files}
+  spec.summary       = %q{Creates polish invoices and proforms as HTML or PDF files}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_dependency 'slim2pdf', '~> 0.0.2'
+end

data/test/invoice_test.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+require 'test_helper'
+
+module PolishInvoicer
+  class InvoiceTest < MiniTest::Unit::TestCase
+    def test_init
+      i = Invoice.new
+      assert i.is_a?(Invoice)
+    end
+
+    def test_set_available_param
+      i = Invoice.new({number: '1/2014'})
+      assert_equal '1/2014', i.number
+    end
+
+    def test_set_unavailable_param
+      assert_raises(RuntimeError) { i = Invoice.new({test: 'abc'}) }
+    end
+
+    def test_validation_delegation
+      i = Invoice.new
+      assert_equal false, i.valid?
+      assert i.errors[:number]
+      i.number = '1/2014'
+      i.valid?
+      assert_nil i.errors[:number]
+    end
+
+    def test_net_value
+      i = Invoice.new({price: 123.45, gross_price: false, vat: 23})
+      assert_in_delta 123.45, i.net_value, 0.01
+      i.gross_price = true
+      assert_in_delta 100.37, i.net_value, 0.01
+      i.vat = 0
+      assert_in_delta 123.45, i.net_value, 0.01
+      i.vat = -1
+      assert_in_delta 123.45, i.net_value, 0.01
+      i.gross_price = false
+      i.vat = 0
+      assert_in_delta 123.45, i.net_value, 0.01
+      i.vat = -1
+      assert_in_delta 123.45, i.net_value, 0.01
+    end
+
+    def test_vat_value
+      i = Invoice.new({price: 123.45, gross_price: false, vat: 23})
+      assert_in_delta 28.39, i.vat_value, 0.01
+      i.gross_price = true
+      assert_in_delta 23.08, i.vat_value, 0.01
+      i.vat = 0
+      assert_equal 0.00, i.vat_value
+      i.vat = -1
+      assert_equal 0.00, i.vat_value
+    end
+
+    def test_gross_value
+      i = Invoice.new({price: 123.45, gross_price: false, vat: 23})
+      assert_in_delta 151.84, i.gross_value, 0.01
+      i.gross_price = true
+      assert_in_delta 123.45, i.gross_value, 0.01
+      i.vat = 0
+      assert_in_delta 123.45, i.gross_value, 0.01
+      i.vat = -1
+      assert_in_delta 123.45, i.gross_value, 0.01
+      i.gross_price = false
+      i.vat = 0
+      assert_in_delta 123.45, i.gross_value, 0.01
+      i.vat = -1
+      assert_in_delta 123.45, i.gross_value, 0.01
+    end
+
+    def test_defaults
+      i = Invoice.new
+      assert i.gross_price
+      assert 23, i.vat
+      assert 'Przelew', i.payment_type
+      assert i.paid
+      assert_equal false, i.proforma
+    end
+
+    def test_raise_when_save_to_html_and_not_valid
+      i = Invoice.new
+      assert_raises(RuntimeError) { i.save_to_html('/tmp/test.html') }
+    end
+
+    def test_raise_when_save_to_pdf_and_not_valid
+      i = Invoice.new
+      assert_raises(RuntimeError) { i.save_to_pdf('/tmp/test.pdf') }
+    end
+
+    def test_save_to_html
+      i = create_valid_invoice
+      path = '/tmp/test.html'
+      i.save_to_html(path)
+      assert File.exists?(path)
+      File.unlink(path)
+    end
+
+    def test_save_to_pdf
+      i = create_valid_invoice
+      path = '/tmp/test.pdf'
+      i.save_to_pdf(path)
+      assert File.exists?(path)
+      File.unlink(path)
+    end
+
+    def test_to_hash
+      i = Invoice.new({price: 123.45, gross_price: false})
+      h = i.to_hash
+      assert h[:paid] # default
+      assert_equal false, h[:gross_price] # params
+      assert_equal '123,45', h[:net_value] # presenter
+    end
+  end
+end

data/test/presenter_test.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require 'test_helper'
+
+module PolishInvoicer
+  class PresenterTest < MiniTest::Unit::TestCase
+    require 'ostruct'
+
+    def setup
+      @invoice = OpenStruct.new
+    end
+
+    def test_format_dates
+      @invoice.trade_date = Date.parse('2014-01-01')
+      @invoice.create_date = Date.parse('2014-01-15')
+      @invoice.payment_date = Date.parse('2014-01-30')
+      data = Presenter.new(@invoice).data
+      assert_equal '01.01.2014', data[:trade_date]
+      assert_equal '15.01.2014', data[:create_date]
+      assert_equal '30.01.2014', data[:payment_date]
+    end
+
+    def test_format_prices
+      @invoice.net_value = 123.4567
+      @invoice.vat_value = 23.9876
+      @invoice.gross_value = 456.3378
+      data = Presenter.new(@invoice).data
+      assert_equal '123,46', data[:net_value]
+      assert_equal '23,99', data[:vat_value]
+      assert_equal '456,34', data[:gross_value]
+    end
+
+    def test_format_comments
+      @invoice.comments = nil
+      data = Presenter.new(@invoice).data
+      assert_equal [], data[:comments]
+      @invoice.comments = 'Test'
+      data = Presenter.new(@invoice).data
+      assert_equal ['Test'], data[:comments]
+      @invoice.comments = ['A', 'B']
+      data = Presenter.new(@invoice).data
+      assert_equal ['A', 'B'], data[:comments]
+    end
+
+    def test_vat
+      @invoice.vat = 23
+      data = Presenter.new(@invoice).data
+      assert_equal '23%', data[:vat]
+      @invoice.vat = 0
+      data = Presenter.new(@invoice).data
+      assert_equal '0%', data[:vat]
+      @invoice.vat = -1
+      data = Presenter.new(@invoice).data
+      assert_equal 'zw.', data[:vat]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'polish_invoicer'
+require 'minitest/autorun'
+
+def create_valid_invoice
+  invoice = PolishInvoicer::Invoice.new({
+    number: '1/2014', create_date: Date.today, trade_date: Date.today,
+    seller: ['Seller'], buyer: ['Buyer'],
+    seller_nip: '123-123-22-33', buyer_nip: '554-333-22-11',
+    item_name: 'Title', price: 123.45, payment_date: Date.today
+  })
+  assert invoice.valid?
+  invoice
+end

data/test/validator_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+
+module PolishInvoicer
+  class ValidatorTest < MiniTest::Unit::TestCase
+    require 'ostruct'
+
+    def setup
+      @invoice = OpenStruct.new
+    end
+
+    def check_error(field, value=nil)
+      @invoice.send("#{field}=", value)
+      v = Validator.new(@invoice)
+      v.valid?
+      assert v.errors[field]
+    end
+
+    def check_ok(field, value=nil)
+      @invoice.send("#{field}=", value)
+      v = Validator.new(@invoice)
+      v.valid?
+      assert_nil v.errors[field]
+    end
+
+    def test_number_validation
+      check_error(:number)
+      check_ok(:number, '1/2014')
+    end
+
+    def test_create_date_validation
+      check_error(:create_date)
+      check_error(:create_date, 'test')
+      check_error(:create_date, 100)
+      check_error(:create_date, '2014-01-01')
+      check_ok(:create_date, Date.parse('2014-01-01'))
+    end
+
+    def test_trade_date_validation
+      check_error(:trade_date)
+      check_error(:trade_date, 'test')
+      check_error(:trade_date, 100)
+      check_error(:trade_date, '2014-01-01')
+      check_ok(:trade_date, Date.parse('2014-01-01'))
+    end
+
+    def test_seller_validation
+      check_error(:seller)
+      check_error(:seller, 'test')
+      check_ok(:seller, ['Jan Nowak', 'Gdynia'])
+    end
+
+    def test_buyer_validation
+      check_error(:buyer)
+      check_error(:buyer, 'test')
+      check_ok(:buyer, ['Jan Nowak', 'Gdynia'])
+    end
+
+    def test_item_name_validation
+      check_error(:item_name)
+      check_ok(:item_name, 'test')
+    end
+
+    def test_price_validation
+      check_error(:price)
+      check_error(:price, 'test')
+      check_error(:price, '100')
+      check_error(:price, -10)
+      check_ok(:price, 19.99)
+    end
+
+    def test_gross_price_validation
+      check_error(:gross_price)
+      check_error(:gross_price, 'test')
+      check_ok(:gross_price, true)
+      check_ok(:gross_price, false)
+    end
+
+    def test_vat_validation
+      check_error(:vat)
+      check_error(:vat, '23')
+      check_error(:vat, 100)
+      check_ok(:vat, 8)
+      check_ok(:vat, -1)
+    end
+
+    def test_payment_type_validation
+      check_error(:payment_type)
+      check_ok(:payment_type, 'Przelew')
+    end
+
+    def test_payment_date_validation
+      check_error(:payment_date)
+      check_error(:payment_date, 'test')
+      check_error(:payment_date, 100)
+      check_error(:payment_date, '2014-01-01')
+      check_ok(:payment_date, Date.parse('2014-01-01'))
+    end
+
+    def test_paid_validation
+      check_error(:paid)
+      check_error(:paid, 'test')
+      check_ok(:paid, true)
+      check_ok(:paid, false)
+    end
+
+    def test_proforma_validation
+      check_error(:proforma)
+      check_error(:proforma, 'test')
+      check_ok(:proforma, true)
+      check_ok(:proforma, false)
+    end
+
+    def test_proforma_could_not_be_paid
+      @invoice.paid = true
+      @invoice.proforma = true
+      v = Validator.new(@invoice)
+      v.valid?
+      assert v.errors[:paid]
+      @invoice.paid = false
+      v = Validator.new(@invoice)
+      v.valid?
+      assert_nil v.errors[:paid]
+    end
+
+    def test_seller_and_buyer_nip_presence
+      check_error(:seller_nip)
+      check_error(:buyer_nip)
+      check_ok(:seller_nip, '123')
+      check_ok(:buyer_nip, '123')
+    end
+
+    def check_dates_ok(create_date, trade_date, msg=nil)
+      @invoice.create_date = Date.parse(create_date)
+      @invoice.trade_date = Date.parse(trade_date)
+      v = Validator.new(@invoice); v.valid?
+      assert_nil v.errors[:create_date], msg
+    end
+
+    def check_dates_error(create_date, trade_date, msg=nil)
+      @invoice.create_date = Date.parse(create_date)
+      @invoice.trade_date = Date.parse(trade_date)
+      v = Validator.new(@invoice); v.valid?
+      assert v.errors[:create_date], msg
+    end
+
+    # data wystawienia max 30 dni przed wykonaniem usługi
+    def test_create_and_trade_date_correlation_before_trade
+      check_dates_ok('2014-01-01', '2014-01-01', 'B1')
+      check_dates_ok('2014-01-01', '2014-01-31', 'B2')
+      check_dates_error('2014-01-01', '2014-02-01', 'B3')
+      check_dates_ok('2014-01-02', '2014-02-01', 'B4')
+    end
+
+    # data wystawienie max 15 dnia następnego miesiąca po wykonaniu usługi
+    def test_create_and_trade_date_correlation_after_trade
+      check_dates_ok('2014-02-15', '2014-01-01', 'A1')
+      check_dates_error('2014-02-16', '2014-01-01', 'A2')
+      check_dates_error('2014-02-16', '2014-01-02', 'A3')
+      check_dates_error('2014-02-16', '2014-01-31', 'A4')
+      check_dates_ok('2014-02-15', '2014-01-31', 'A5')
+      check_dates_ok('2014-03-15', '2014-02-15', 'A6')
+    end
+
+    def test_no_vat_reason_presence
+      @invoice.vat = 23
+      v = Validator.new(@invoice); v.valid?
+      assert_nil v.errors[:no_vat_reason]
+      @invoice.vat = -1
+      v = Validator.new(@invoice); v.valid?
+      assert v.errors[:no_vat_reason]
+      @invoice.no_vat_reason = 'reason'
+      v = Validator.new(@invoice); v.valid?
+      assert_nil v.errors[:no_vat_reason]
+    end
+  end
+end