Class: Invoicing::LedgerItem::RenderUBL::UBLOutputBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/invoicing/ledger_item/render_ubl.rb

Overview

:nodoc:

Constant Summary collapse

UBL_NAMESPACES =

XML Namespaces required by UBL

{
  "xmlns:cac" => "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
  "xmlns:cbc" => "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
}
UBL_DOC_NAMESPACES = 
{
  :Invoice              => "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2",
  :SelfBilledInvoice    => "urn:oasis:names:specification:ubl:schema:xsd:SelfBilledInvoice-2",
  :CreditNote           => "urn:oasis:names:specification:ubl:schema:xsd:CreditNote-2",
  :SelfBilledCreditNote => "urn:oasis:names:specification:ubl:schema:xsd:SelfBilledCreditNote-2"
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(ledger_item, options) ⇒ UBLOutputBuilder

Returns a new instance of UBLOutputBuilder.



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 50

def initialize(ledger_item, options)
  @ledger_item = ledger_item
  @options = options
  @cached_values = {}
  subtype = ledger_item.send(:ledger_item_class_info).subtype
  @doc_type = 
    if [:invoice, :credit_note].include? subtype
      if total_amount >= BigDecimal('0')
        @factor = BigDecimal('1')
        sender_details.symbolize_keys[:is_self] ? :Invoice : :SelfBilledInvoice
      else
        @factor = BigDecimal('-1')
        sender_details.symbolize_keys[:is_self] ? :CreditNote : :SelfBilledCreditNote
      end
    else
      raise RuntimeError, "render_ubl not implemented for ledger item subtype #{subtype.inspect}"
    end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_id, *args, &block) ⇒ Object

For convenience while building the XML structure, method_missing redirects method calls to the ledger item (taking account of method renaming via acts_as_ledger_item options); calls to foo_of(line_item) are redirected to line_item.foo (taking account of method renaming via acts_as_line_item options).



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 73

def method_missing(method_id, *args, &block)
  method_id = method_id.to_sym
  if method_id.to_s =~ /^(.*)_of$/
    method_id = $1.to_sym
    line_item = args[0]
    line_item.send(:line_item_class_info).get(line_item, method_id)
  else
    cached_values[method_id] ||= ledger_item.send(:ledger_item_class_info).get(ledger_item, method_id)
  end
end

Instance Attribute Details

#cached_values ⇒ Object (readonly)

Returns the value of attribute cached_values.



48
49
50
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 48

def cached_values
  @cached_values
end

#doc_type ⇒ Object (readonly)

Returns the value of attribute doc_type.



48
49
50
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 48

def doc_type
  @doc_type
end

#factor ⇒ Object (readonly)

Returns the value of attribute factor.



48
49
50
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 48

def factor
  @factor
end

#ledger_item ⇒ Object (readonly)

Returns the value of attribute ledger_item.



48
49
50
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 48

def ledger_item
  @ledger_item
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



48
49
50
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 48

def options
  @options
end

Instance Method Details

#build ⇒ Object

Returns a UBL XML rendering of the ledger item previously passed to the constructor.



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 85

def build
  ubl = Builder::XmlMarkup.new :indent => 4
  ubl.instruct! :xml
  
  ubl.ubl doc_type, UBL_NAMESPACES.clone.update({'xmlns:ubl' => UBL_DOC_NAMESPACES[doc_type]}) do |invoice|
    invoice.cbc :ID, identifier
    invoice.cbc :UUID, uuid if uuid
    
    issue_date_formatted, issue_time_formatted = date_and_time(issue_date || Time.now)
    invoice.cbc :IssueDate, issue_date_formatted
    invoice.cbc :IssueTime, issue_time_formatted
    
    # Different document types have the child elements InvoiceTypeCode, Note and
    # TaxPointDate in a different order. WTF?!
    if doc_type == :Invoice
      invoice.cbc :InvoiceTypeCode, method_missing(:type)
      invoice.cbc :Note, description
      invoice.cbc :TaxPointDate, issue_date_formatted
    else
      invoice.cbc :TaxPointDate, issue_date_formatted
      invoice.cbc :InvoiceTypeCode, method_missing(:type) if doc_type == :SelfBilledInvoice
      invoice.cbc :Note, description
    end
    
    invoice.cac :InvoicePeriod do |invoice_period|
      build_period(invoice_period, period_start, period_end)
    end if period_start && period_end
    
    if [:Invoice, :CreditNote].include?(doc_type)
    
      invoice.cac :AccountingSupplierParty do |supplier|
        build_party supplier, sender_details
      end
      invoice.cac :AccountingCustomerParty do |customer|
        customer.cbc :SupplierAssignedAccountID, recipient_id
        build_party customer, recipient_details
      end
      
    elsif [:SelfBilledInvoice, :SelfBilledCreditNote].include?(doc_type)
    
      invoice.cac :AccountingCustomerParty do |customer|
        build_party customer, recipient_details
      end
      invoice.cac :AccountingSupplierParty do |supplier|
        supplier.cbc :CustomerAssignedAccountID, sender_id
        build_party supplier, sender_details
      end
      
    end
    
    invoice.cac :PaymentTerms do |payment_terms|
      payment_terms.cac :SettlementPeriod do |settlement_period|
        build_period(settlement_period, issue_date || Time.now, due_date)
      end
    end if due_date && [:Invoice, :SelfBilledInvoice].include?(doc_type)
    
    invoice.cac :TaxTotal do |tax_total|
      tax_total.cbc :TaxAmount, (factor*tax_amount).to_s, :currencyID => currency
    end if tax_amount
    
    invoice.cac :LegalMonetaryTotal do |monetary_total|
      monetary_total.cbc :TaxExclusiveAmount, (factor*(total_amount - tax_amount)).to_s,
        :currencyID => currency if tax_amount
      monetary_total.cbc :PayableAmount, (factor*total_amount).to_s, :currencyID => currency
    end
    
    line_items.sorted(:tax_point).each do |line_item|
      line_tag = if [:CreditNote, :SelfBilledCreditNote].include? doc_type
        :CreditNoteLine
      else
        :InvoiceLine
      end
      
      invoice.cac line_tag do |invoice_line|
        build_line_item(invoice_line, line_item)
      end
    end
  end
  ubl.target!
end

#build_line_item(invoice_line, line_item) ⇒ Object

Given a Builder::XmlMarkup instance and a LineItem instance, builds a UBL representation of that line item, something like the following:

<cbc:ID>123</cbc:ID>
<cbc:UUID>0cc659f0-cfac-012b-481d-0017f22d32c0</cbc:UUID>
<cbc:InvoicedQuantity>1</cbc:InvoicedQuantity>
<cbc:LineExtensionAmount currencyID="GBP">123.45</cbc:LineExtensionAmount>
<cbc:TaxPointDate>2009-01-01</cbc:TaxPointDate>
<cac:TaxTotal><cbc:TaxAmount currencyID="GBP">12.34</cbc:TaxAmount></cac:TaxTotal>
<cac:Item><cbc:Description>Foo bar baz</cbc:Description></cac:Item>



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 244

def build_line_item(invoice_line, line_item)
  invoice_line.cbc :ID, id_of(line_item)
  invoice_line.cbc :UUID, uuid_of(line_item) if uuid_of(line_item)
  quantity_tag = [:Invoice, :SelfBilledInvoice].include?(doc_type) ? :InvoicedQuantity : :CreditedQuantity
  invoice_line.cbc quantity_tag, quantity_of(line_item) if quantity_of(line_item)
  invoice_line.cbc :LineExtensionAmount, (factor*net_amount_of(line_item)).to_s, :currencyID => currency
  if tax_point_of(line_item)
    tax_point_date, tax_point_time = date_and_time(tax_point_of(line_item))
    invoice_line.cbc :TaxPointDate, tax_point_date
  end
  
  invoice_line.cac :TaxTotal do |tax_total|
    tax_total.cbc :TaxAmount, (factor*tax_amount_of(line_item)).to_s, :currencyID => currency
  end if tax_amount_of(line_item)
  
  invoice_line.cac :Item do |item|
    item.cbc :Description, description_of(line_item)
    #cac:BuyersItemIdentification
    #cac:SellersItemIdentification
    #cac:ClassifiedTaxCategory
    #cac:ItemInstance
  end
    
  #cac:Price
end

#build_party(xml, details) ⇒ Object

Given a Builder::XmlMarkup instance and a supplier/customer details hash (as returned by LedgerItem#sender_details and LedgerItem#recipient_details, builds a UBL representation of that party, something like the following:

<cac:Party>
    <cac:PartyName>
        <cbc:Name>The Big Bank</cbc:Name>
    </cac:PartyName>
    <cac:PostalAddress>
        <cbc:StreetName>Paved With Gold Street</cbc:StreetName>
        <cbc:CityName>London</cbc:CityName>
        <cbc:PostalZone>E14 5HQ</cbc:PostalZone>
        <cac:Country><cbc:IdentificationCode>GB</cbc:IdentificationCode></cac:Country>
    </cac:PostalAddress>
</cac:Party>



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 200

def build_party(xml, details)
  details = details.symbolize_keys
  xml.cac :Party do |party|
    party.cac :PartyName do |party_name|
      party_name.cbc :Name, details[:name]
    end if details[:name]
    
    party.cac :PostalAddress do |postal_address|
      street1, street2 = details[:address].strip.split("\n", 2)
      postal_address.cbc :StreetName,           street1               if street1
      postal_address.cbc :AdditionalStreetName, street2               if street2
      postal_address.cbc :CityName,             details[:city]        if details[:city]
      postal_address.cbc :PostalZone,           details[:postal_code] if details[:postal_code]
      postal_address.cbc :CountrySubentity,     details[:state]       if details[:state]
      postal_address.cac :Country do |country|
        country.cbc :IdentificationCode, details[:country_code] if details[:country_code]
        country.cbc :Name,               details[:country]      if details[:country]
      end if details[:country_code] || details[:country]
    end
    
    party.cac :PartyTaxScheme do |party_tax_scheme|
      party_tax_scheme.cbc :CompanyID, details[:tax_number]
      party_tax_scheme.cac :TaxScheme do |tax_scheme|
        tax_scheme.cbc :ID, "VAT" # TODO: make country-dependent (e.g. GST in Australia)
      end
    end if details[:tax_number]
    
    party.cac :Contact do |contact|
      contact.cbc :Name, details[:contact_name]
    end if details[:contact_name]
  end
end

#build_period(xml, start_datetime, end_datetime) ⇒ Object

Given a Builder::XmlMarkup instance and two datetime objects, builds a UBL representation of the period between the two dates and times, something like the following:

<cbc:StartDate>2008-05-06</cbc:StartTime>
<cbc:StartTime>12:34:56+02:00</cbc:StartTime>
<cbc:EndDate>2008-07-02</cbc:EndDate>
<cbc:EndTime>01:02:03+02:00</cbc:EndTime>



175
176
177
178
179
180
181
182
 
# File 'lib/invoicing/ledger_item/render_ubl.rb', line 175

def build_period(xml, start_datetime, end_datetime)
  start_date, start_time = date_and_time(start_datetime)
  end_date, end_time = date_and_time(end_datetime)
  xml.cbc :StartDate, start_date
  xml.cbc :StartTime, start_time
  xml.cbc :EndDate, end_date
  xml.cbc :EndTime, end_time
end