nf-e 0.2.26

data/lib/nfe/helpers/xml_model/attribute_text.rb

@@ -0,0 +1,31 @@
+module Nfe
+  module Helpers
+    module XmlModel
+      class AttributeText < AttributeBase
+        def format
+          @format || "%s"
+        end
+
+        private
+
+        def add_element(attribute)
+          format % normalize_attribute(attribute)
+        end
+
+        def normalize_attribute(attribute)
+          attribute.to_s.
+            gsub(/\n/, " ").
+            gsub(/\r/, " ").
+            gsub(/\s+/, " ").
+            gsub(/&/, "&amp;").
+            gsub(/</, "&lt;").
+            gsub(/>/, "&gt;").
+            gsub(/\"/, "&quot;").
+            gsub(/\'/, "&#39;").
+            gsub(/[(ÿ-\uFFFF| )]/, " ").
+            gsub(/  +/, " ")
+        end
+      end
+    end
+  end
+end

data/lib/nfe/helpers/xml_model/factory.rb

@@ -0,0 +1,17 @@
+module Nfe
+  module Helpers
+    module XmlModel
+      class Factory
+        def self.create(name, options={})
+          type = options[:type] || :text
+
+          if type == :attribute
+            AttributeNodeattribute.new(name, options)
+          else
+            XmlModel::const_get("Attribute#{type.capitalize}").new(name, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nfe/helpers/xml_model/nfe_model.rb

@@ -0,0 +1,120 @@
+module Nfe
+  module Helpers
+    module XmlModel
+      module NfeModel
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def attr_xml(xml_attr, options={})
+            register_xml_attr xml_attr, options
+            register_attr_acessor xml_attribute(xml_attr)
+          end
+
+          def xml_attributes
+            @xml_attributes ||= {}
+            if self.superclass.methods.include?(:xml_attributes)
+              @xml_attributes = self.superclass.xml_attributes.merge @xml_attributes
+            end
+            @xml_attributes
+          end
+
+          def xml_attribute(attribute)
+            xml_attributes[attribute]
+          end
+
+          private
+          def register_xml_attr(xml_attr, options)
+            xml_attributes[xml_attr] = Factory.create xml_attr, options
+          end
+
+          def register_attr_acessor(xml_attr)
+            instance_eval do
+              attr_accessor xml_attr.name unless xml_attr.type.equal? :enumerize
+            end
+          end
+        end
+
+        def present?
+          check_present
+        end
+
+        def check_present
+          present = false
+          self.class.xml_attributes.each do |key, value|
+            present ||= value_present? key, value
+          end
+          present
+        end
+
+        def parse!(xml)
+          parse_elements xml
+        end
+
+        def to_xml
+          xml = Builder::XmlMarkup.new
+
+          add_elements xml
+
+          xml.target!
+        end
+
+        def parse_elements(doc, *elements)
+          doc = Nokogiri::XML(doc) if doc.is_a? String
+
+          elements = get_elements(elements)
+
+          Array(elements).each { |attribute| parse_value doc, attribute }
+        end
+
+        def add_elements(xml, *elements)
+          elements = get_elements(elements)
+
+          Array(elements).each { |attribute| add_element xml, attribute }
+        end
+
+        def validate_optional_attributes(*attributes)
+          attributes.each do |attribute|
+            Array(send(attribute)).each do |item|
+              if item.present? && !item.valid?
+                errors.add(attribute, :invalid) unless errors.include?(attribute)
+              end
+            end
+          end
+        end
+
+        def validate_required_attributes(*attributes)
+          attributes.each do |attribute|
+            if !send(attribute).valid?
+              errors.add(attribute, :invalid) unless errors.include?(attribute)
+            end
+          end
+        end
+
+        private
+        def parse_value(doc, attribute)
+          self.class.xml_attribute(attribute).parse self, doc
+        end
+
+        def add_element(xml, attribute)
+          self.class.xml_attribute(attribute).add_to_xml self, xml, attribute
+        end
+
+        def get_elements(elements)
+          elements = self.class.xml_attributes.keys if elements.empty?
+
+          elements
+        end
+
+        def value_present?(key, value)
+          if value.type.equal? :bigdecimal
+            send(key) > 0
+          else
+            send(key).present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nfe/models/NFe.rb

@@ -0,0 +1,47 @@
+module Nfe
+  module Models
+    class NFe
+      include ActiveModel::Model
+      include Helpers::XmlModel::NfeModel
+
+      attr_accessor :infNFe, :signature
+
+      validate { validate_required_attributes :infNFe }
+
+      def initialize
+        @infNFe = Nfe::Models::InfNFe.new
+        @signature = Nfe::Models::Signature.new
+      end
+
+      def self.namespace
+        "http://www.portalfiscal.inf.br/nfe"
+      end
+
+      def parse!(xml)
+        doc = Nokogiri::XML(xml)
+
+        @infNFe.parse!(doc.css("infNFe").to_xml)
+
+        sign = doc.xpath("//ds:Signature", ds: Signature.namespace).to_xml
+        @signature.parse!(sign)
+      end
+
+      def to_xml
+        xml = Builder::XmlMarkup.new
+
+        xml.NFe(xmlns: Nfe::Models::NFe.namespace) do |nfe|
+
+          nfe.infNFe({versao: infNFe.versao, Id: infNFe.id}) do |node|
+            node << @infNFe.to_xml
+          end
+
+          nfe.Signature(xmlns: Signature.namespace) do |node|
+            node << @signature.value
+          end
+        end
+
+        xml.target!
+      end
+    end
+  end
+end

data/lib/nfe/models/avulsa.rb

@@ -0,0 +1,59 @@
+module Nfe
+  module Models
+    class Avulsa
+      include ActiveModel::Model
+      include Helpers::XmlModel::NfeModel
+
+      attr_xml :cnpj, required: true, xml_alias: "CNPJ"
+      attr_xml :xOrgao, required: true
+      attr_xml :matr, required: true
+      attr_xml :xAgente, required: true
+      attr_xml :fone 
+      attr_xml :uf, required: true, xml_alias: "UF"
+      attr_xml :nDAR
+      attr_xml :dEmi, type: :date
+      attr_xml :vDAR, type: :float
+      attr_xml :repEmi, required: true
+      attr_xml :dPag, type: :date
+
+      validates :cnpj,
+        presence: true,
+        cnpj: true,
+        length: { is: 14}
+
+      validates :xOrgao,
+        length: { in: 1..60 }
+
+      validates :matr,
+        length: { in: 1..60 }
+
+      validates :xAgente,
+        length: { in: 1..60 }
+
+      validates :fone,
+        length: { in: 6..14, allow_blank: true },
+        numericality: { only_integer: true, allow_blank: true }
+
+      validates :uf,
+        length: { is: 2 }
+
+      validates :nDAR,
+        length: { in: 1..60, allow_blank: true }
+
+      validates :dEmi,
+        length: { is: 10, allow_blank: true }
+
+      validates :vDAR,
+        numericality: {
+          greater_than_or_equal_to: 0,
+          less_than_or_equal_to: 9_999_999_999_999.99,
+          allow_blank: true }
+
+      validates :repEmi,
+        length: { in: 1..60 }
+
+      validates :dPag,
+        length: { is: 10, allow_blank: true }
+    end
+  end
+end

data/lib/nfe/models/bill/cobr.rb

@@ -0,0 +1,23 @@
+module Nfe
+  module Models
+    module Bill
+      class Cobr
+        include ActiveModel::Model
+        include Helpers::XmlModel::NfeModel
+
+        attr_xml :fat, type: :node
+        attr_xml :dup, type: :collection, klass: "Nfe::Models::Bill::Dup"
+
+        validates :dup,
+          length: { maximum: 120, message: :less_than_or_equal_to }
+
+        validate { validate_optional_attributes :fat, :dup }
+
+        def initialize
+          @fat = Fat.new
+          @dup = []
+        end
+      end
+    end
+  end
+end

data/lib/nfe/models/bill/dup.rb

@@ -0,0 +1,23 @@
+module Nfe
+  module Models
+    module Bill
+      class Dup
+        include ActiveModel::Model
+        include Helpers::XmlModel::NfeModel
+
+        attr_xml :nDup
+        attr_xml :dVenc, type: :date
+        attr_xml :vDup, type: :float
+
+        validates :nDup,
+          length: { maximum: 60 }
+
+        validates :vDup,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to: 9_999_999_999_999.99,
+            allow_blank: true }
+      end
+    end
+  end
+end

data/lib/nfe/models/bill/fat.rb

@@ -0,0 +1,36 @@
+module Nfe
+  module Models
+    module Bill
+      class Fat
+        include ActiveModel::Model
+        include Helpers::XmlModel::NfeModel
+
+        attr_xml :nFat
+        attr_xml :vOrig, type: :float
+        attr_xml :vDesc, type: :float
+        attr_xml :vLiq, type: :float
+
+        validates :nFat,
+          length: { maximum: 60 }
+
+        validates :vOrig,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to: 9_999_999_999_999.99,
+            allow_blank: true }
+
+        validates :vDesc,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to: 9_999_999_999_999.99,
+            allow_blank: true }
+
+        validates :vLiq,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to: 9_999_999_999_999.99,
+            allow_blank: true }
+      end
+    end
+  end
+end

data/lib/nfe/models/cane/bigdecimal_greater_than_validator.rb

@@ -0,0 +1,11 @@
+class BigdecimalGreaterThanValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    max = BigDecimal("99999999999.9999999999")
+
+    if value > max
+      record.errors.add(attribute,
+        I18n.t("errors.messages.less_than_or_equal_to", count: max.to_s("F")))
+    end
+  end
+end
+

data/lib/nfe/models/cane/bigdecimal_less_than_validator.rb

@@ -0,0 +1,9 @@
+class BigdecimalLessThanValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if value < 0
+      record.errors.add(attribute,
+        I18n.t("errors.messages.greater_than_or_equal_to", count: 0))
+    end
+  end
+end
+

data/lib/nfe/models/cane/cana.rb

@@ -0,0 +1,100 @@
+require_relative "bigdecimal_less_than_validator"
+require_relative "bigdecimal_greater_than_validator"
+
+module Nfe
+  module Models
+    module Cane
+      class Cana
+        include ActiveModel::Model
+        include Helpers::XmlModel::NfeModel
+
+        attr_xml :safra, required: true
+        attr_xml :ref, required: true
+        attr_xml :vFor, type: :float, required: true
+        attr_xml :vTotDed, type: :float, required: true
+        attr_xml :vLiqFor, type: :float, required: true
+        attr_xml :forDia, type: :collection, klass: "Nfe::Models::Cane::ForDia"
+        attr_xml :deduc, type: :collection, klass: "Nfe::Models::Cane::Deduc"
+        attr_xml :qTotMes, type: :bigdecimal, required: true
+        attr_xml :qTotAnt, type: :bigdecimal, required: true
+        attr_xml :qTotGer, type: :bigdecimal, required: true
+
+        validates :safra,
+          length: { in: 4..9 }
+
+        validates :ref,
+          length: { is: 7 }
+
+        validates :qTotMes,
+          bigdecimal_less_than: true,
+          bigdecimal_greater_than: true
+
+        validates :qTotAnt,
+          bigdecimal_less_than: true,
+          bigdecimal_greater_than: true
+
+        validates :qTotGer,
+          bigdecimal_less_than: true,
+          bigdecimal_greater_than: true
+
+        validates :vFor,
+          presence: true,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to: 9_999_999_999_999.99
+          }
+
+        validates :vTotDed,
+          presence: true,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to:  9_999_999_999_999.99
+          }
+
+        validates :vLiqFor,
+          presence: true,
+          numericality: {
+            greater_than_or_equal_to: 0,
+            less_than_or_equal_to:  9_999_999_999_999.99
+          }
+
+        validate { validate_optional_attributes :forDia, :deduc }
+
+        def initialize
+          @qTotMes = BigDecimal("0", 22)
+          @qTotAnt = BigDecimal("0", 22)
+          @qTotGer = BigDecimal("0", 22)
+          @forDia = []
+          @deduc = []
+        end
+
+        def qTotMes=(value)
+          @qTotMes = BigDecimal(value, 22)
+        end
+
+        def qTotAnt=(value)
+          @qTotAnt = BigDecimal(value, 22)
+        end
+
+        def qTotGer=(value)
+          @qTotGer = BigDecimal(value, 22)
+        end
+
+        def to_xml
+          xml = Builder::XmlMarkup.new
+
+          add_elements xml, :safra, :ref
+
+          @forDia.each do |forDia|
+            xml.forDia(dia: forDia.dia) { |node| node << forDia.to_xml }
+          end
+
+          add_elements xml, :qTotMes, :qTotAnt, :qTotGer, :deduc, :vFor,
+            :vTotDed, :vLiqFor
+
+          xml.target!
+        end
+      end
+    end
+  end
+end