invoicing_payments_processing 1.1.4 → 1.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34bca7e013f48b4303f62310d10af93adb0150d5
-  data.tar.gz: d5be57777768cf864a273d34c87350fc7b48e124
+  metadata.gz: 079660aadfbd7106fcc74787e3d86002375ec4b2
+  data.tar.gz: 281a650e189be44ed7e91ca2bf439e876f014eb8
 SHA512:
-  metadata.gz: dc65a5b539e09a60dbdcc71ebf4cc1ff4c718f8235bbd6c7fe989b34fbd3daf4e32bd5ef9b053cf842e4e75855295d8185c5da1b8e86052c0a18a7fd915d84fd
-  data.tar.gz: d71ff8365ca5a3142faee45b8da1de7a11b6c0a42b1169e7c493b9b38cd21e6b167676dc99aa2a499670aa03bfa615fd1c9b98af0b583218076ff9c720ec04d2
+  metadata.gz: 025fd8f5d7060f21b8bdd2e2d1d087ee57d3ac587c32b8c0aaf03f53fba263da0904b21a00d85d5c6d6fe9c220155783e9541bf2ba5dbf8c49aff3c0e58bea82
+  data.tar.gz: 875037f5c24e6702cfcb8c39bca913d22761e2f1a7ca3d8efe6707edc30a8a8ec0c12e24fdc22da2fb4fa7d1517f5c0463d85aed2744429de5ff77ffa5ecda14

data/lib/bufferpaypalnotification.rb

@@ -43,13 +43,19 @@ module BlackStack
     def get_client()
       # obtengo el cliente que machea con este perfil
       c = nil
-      if (c == nil)
+      if c.nil?
+        if self.invoice.guid?
+          i = BlackStack::Invoice.where(:id=>self.invoice).first
+          c = i.client if !i.nil? 
+        end
+      end
+      if c.nil?
         cid = self.invoice.split(".").first.to_s
         if cid.guid?
           c = BlackStack::Client.where(:id=>cid).first
         end
       end
-      if (c == nil)
+      if c.nil?
         c = BlackStack::Client.where(:paypal_email=>self.payer_email).first
         if (c == nil)
           u = User.where(:email=>self.payer_email).first
@@ -58,13 +64,13 @@ module BlackStack
           end
         end
       end
-      if (c == nil)
+      if c.nil?
         s = BlackStack::PayPalSubscription.where(:payer_email=>self.payer_email).first
         if (s!=nil)
           c = s.client
         end
       end
-      if (c == nil)
+      if c.nil?
         # obtengo el cliente - poco elegante
         q = 
         "SELECT TOP 1 i.id_client AS cid " +
@@ -288,6 +294,7 @@ module BlackStack
   
           # le asigno el id_buffer_paypal_notification
           i.id_buffer_paypal_notification = b.id
+					i.subscr_id = b.subscr_id
           i.save
     
           # marco la factura como pagada
@@ -363,6 +370,19 @@ module BlackStack
               raise 'Invoice already exists.'
             end
             
+            # obtengo la ultima factura pagada, vinculada a un IPN con el mismo codigo invoice
+            row = DB[
+              "SELECT TOP 1 i.id " +
+              "FROM buffer_paypal_notification b " +
+              "JOIN invoice i ON ( b.id=i.id_buffer_paypal_notification AND i.status=#{BlackStack::Invoice::STATUS_PAID.to_s} ) " +
+              "WHERE b.invoice='#{b.invoice}' " +
+              "ORDER BY i.create_time DESC "
+            ].first
+            if row.nil?
+              raise 'Previous Paid Invoice not found.'
+            end
+            k = BlackStack::Invoice.where(:id=>row[:id]).first
+            
             # creo la factura por el reembolso
             i = BlackStack::Invoice.new()
             i.id = guid()
@@ -378,7 +398,7 @@ module BlackStack
             i.save()
             
             # parseo el reeembolso - creo el registro contable
-            i.setup_refund(payment_gross, iid)
+            i.setup_refund(payment_gross, k.id)
   
           end
         else

data/lib/extend_client_by_invoicing_payments_processing.rb

@@ -10,9 +10,112 @@ module BlackStack
 
       # crea/actualiza un registro en la tabla movment, reduciendo la cantidad de creditos y saldo que tiene el cliente, para el producto indicado en product_code. 
       def consume(product_code, number_of_credits=1, description=nil)
-        DB.execute("exec reduceDebt '#{product_code.to_sql}', '#{self.id}', #{number_of_credits.to_s}, '#{description.to_s.to_sql}'")
+				# create the consumtion
+				total_credits = 0.to_f - BlackStack::Balance.new(self.id, product_code).credits.to_f
+				total_amount = 0.to_f - BlackStack::Balance.new(self.id, product_code).amount.to_f
+				ratio = total_credits == 0 ? 0.to_f : total_amount.to_f / total_credits.to_f
+				amount = number_of_credits.to_f * ratio
+				cons = BlackStack::Movement.new
+				cons.id = guid()
+				cons.id_client = self.id
+				cons.create_time = now()
+				cons.type = BlackStack::Movement::MOVEMENT_TYPE_CANCELATION
+				cons.description = description.nil? ? 'Consumption' : description
+				cons.paypal1_amount = 0
+				cons.bonus_amount = 0
+				cons.amount = amount
+				cons.credits = number_of_credits
+				cons.profits_amount = -amount
+				cons.product_code = product_code
+				cons.expiration_time = nil
+				cons.save
+				# if there is negative credits
+				prod = BlackStack::InvoicingPaymentsProcessing.product_descriptor(product_code)
+				total_credits = 0.to_f - BlackStack::Balance.new(self.id, product_code).credits.to_f
+				total_amount = 0.to_f - BlackStack::Balance.new(self.id, product_code).amount.to_f
+				sleep(2) # delay to ensure the time of the bonus movement will be later than the time of the consumption movement
+				if total_credits < 0
+					self.adjustment(product_code, total_amount, total_credits, 'Adjustment Because Quota Has Been Exceeded.')
+				end
+				# recaculate amounts in both consumptions and expirations - CANCELADO - Se debe hacer offline
+				#self.recalculate(product_code) 
+				# return
+				cons
       end
-    
+
+      # crea un registro en la tabla movment, reduciendo la cantidad de creditos con saldo importe 0, para el producto indicado en product_code. 
+      def bonus(product_code, expiration, number_of_credits=1, description=nil)				
+				bonus_amount = 0 # Los bonos siempre son por un importa igual a 0.
+				
+				bonus = BlackStack::Movement.new
+				bonus.id = guid()
+				bonus.id_client = self.id
+				bonus.create_time = now()
+				bonus.type = BlackStack::Movement::MOVEMENT_TYPE_ADD_BONUS
+				bonus.description = description.nil? ? 'Bonus' : description
+				bonus.paypal1_amount = 0
+				bonus.bonus_amount = bonus_amount
+				bonus.amount = -bonus_amount
+				bonus.credits = -number_of_credits
+				bonus.profits_amount = 0
+				bonus.product_code = product_code
+				bonus.expiration_time = expiration
+				bonus.save
+				# recalculate - CANCELADO
+				#bonus.recalculate
+				# return
+				bonus
+      end
+
+      # crea un registro en la tabla movment, reduciendo la cantidad de creditos con saldo importe 0, para el producto indicado en product_code. 
+      def adjustment(product_code, adjustment_amount=0, adjustment_credits=0, description=nil, type=BlackStack::Movement::MOVEMENT_TYPE_ADJUSTMENT)
+				adjust = BlackStack::Movement.new
+				adjust.id = guid()
+				adjust.id_client = self.id
+				adjust.create_time = now()
+				adjust.type = type
+				adjust.description = description.nil? ? 'Adjustment' : description
+				adjust.paypal1_amount = 0
+				adjust.bonus_amount = 0
+				adjust.amount = adjustment_amount
+				adjust.credits = adjustment_credits
+				adjust.profits_amount = -adjustment_amount
+				adjust.product_code = product_code
+				adjust.expiration_time = nil
+				adjust.save
+				adjust
+      end
+
+			# recalculate the amount for all the consumptions, expirations, and adjustments
+			def recalculate(product_code)
+				# 
+				amount_paid = 0.to_f
+				credits_paid = 0
+
+				#total_credits = 0.to_f - BlackStack::Balance.new(self.id, product_code).credits.to_f
+				#total_amount = 0.to_f - BlackStack::Balance.new(self.id, product_code).amount.to_f
+
+				self.movements.select { |o| 
+					o.product_code.upcase == product_code.upcase
+				}.sort_by { |o| o.create_time }.each { |o|
+					#if o.credits.to_f < 0 # payment or bonus
+#					if o.credits.to_f > 0 && ( o.type==BlackStack::Movement::MOVEMENT_TYPE_CANCELATION || o.type==BlackStack::Movement::MOVEMENT_TYPE_EXPIRATION ) # consumption or expiration
+					# consumption or expiration or bonus
+					if ( 
+						o.type==BlackStack::Movement::MOVEMENT_TYPE_CANCELATION || 
+						o.type==BlackStack::Movement::MOVEMENT_TYPE_EXPIRATION || 
+						o.type==BlackStack::Movement::MOVEMENT_TYPE_ADJUSTMENT
+					)
+						x = credits_paid.to_f == 0 ? 0 : o.credits.to_f * ( amount_paid.to_f / credits_paid.to_f )
+						o.amount = x
+						o.profits_amount = -x
+						o.save
+					end
+					amount_paid += 0.to_f - o.amount.to_f
+					credits_paid += 0.to_i - o.credits.to_i
+				}
+			end 
+		
       # TODO: el cliente deberia tener una FK a la tabla division. La relacion no puede ser N-N.
       # TODO: se debe preguntar a la central
       def division

data/lib/invoice.rb

@@ -11,6 +11,7 @@ module BlackStack
     many_to_one :buffer_paypal_notification, :class=>:'BlackStack::BufferPayPalNotification', :key=>:id_buffer_paypal_notification
     many_to_one :client, :class=>:'BlackStack::Client', :key=>:id_client
     many_to_one :paypal_subscription, :class=>:'BlackStack::PayPalSubscription', :key=>:id_paypal_subscription
+		many_to_one :previous, :class=>:'BlackStack::Invoice', :key=>:id_previous_invoice
     one_to_many :items, :class=>:'BlackStack::InvoiceItem', :key=>:id_invoice
   
     # compara 2 planes, y retorna TRUE si ambos pueden coexistir en una misma facutra, con un mismo enlace de PayPal
@@ -269,24 +270,67 @@ module BlackStack
       self.save()
     end
   
-    # cambia el estado de la factura de UNPAID a PAID
-    # verifica que el estado de la factura sea NULL o UNPAID
-    # crea los registros contables por el pago de esta factura 
-    def getPaid()
+    # Verifica que el estado de la factura sea NULL o UNPAID.
+    # Cambia el estado de la factura de UNPAID a PAID.
+    # Crea los registros contables por el pago de esta factura: un registro por cada item, y por cada bono del plan en cada item.
+		# Los registros en la table de movimientos se registraran con la fecha del parametro sql_payment_datetime.
+		# Las fechas de expiracion de los movimientos se calculan seguin la fecha del pago.
+		# 
+		# sql_payment_datetime: Fecha-hora del pago. Por defecto es la fecha-hora actual.
+		# 
+    def getPaid(payment_time=nil)
+			payment_time = Time.now() if payment_time.nil?
+		
       if self.canBePaid? == false
         raise "Method BlackStack::Invoice::getPaid requires the current status is nil or unpaid."
       end
       # marco la factura como pagada
       self.status = BlackStack::Invoice::STATUS_PAID
       self.save
+			# expiracion de creditos de la factura anterior
+			i = self.previous
+			if !i.nil?
+				InvoiceItem.where(:id_invoice=>i.id).all { |item|
+					# 
+					BlackStack::Movement.where(:id_invoice_item => item.id).all { |mov|
+						# 
+						mov.expire if mov.expiration_on_next_payment == true
+						#
+						DB.disconnect
+						GC.start
+					} # BlackStack::Movement.where(:id_invoice_item => item.id).all { |mov|
+					#
+					DB.disconnect
+					GC.start
+				} # InvoiceItem.where(:id_invoice=>i.id).all { |item|
+			end
       # registro los asientos contables
-      InvoiceItem.where(:id_invoice=>self.id).all { |item|      
-        BlackStack::Movement.new().parse(item, BlackStack::Movement::MOVEMENT_TYPE_ADD_PAYMENT, "Invoice Payment").save()
+      InvoiceItem.where(:id_invoice=>self.id).all { |item|
+				# obtengo descriptor del plan
+				plan = BlackStack::InvoicingPaymentsProcessing.plan_descriptor(item.item_number)
+				# obtengo descriptor del producto
+				prod = BlackStack::InvoicingPaymentsProcessing.product_descriptor(plan[:product_code])
+				# registro el pago
+        BlackStack::Movement.new().parse(item, BlackStack::Movement::MOVEMENT_TYPE_ADD_PAYMENT, "Invoice Payment", payment_time, item.id).save()
+				# agrego los bonos de este plan
+				plan[:bonus_plans].each { |h|
+					plan_bonus = BlackStack::InvoicingPaymentsProcessing.plan_descriptor(h[:item_number])
+					raise "bonus plan not found" if plan_bonus.nil?					
+					bonus = BlackStack::InvoiceItem.new
+					bonus.id = guid()
+					bonus.id_invoice = self.id
+					bonus.product_code = plan_bonus[:product_code]
+					bonus.unit_price = 0
+					bonus.units = plan_bonus[:credits]
+					bonus.amount = 0
+					bonus.item_number = plan_bonus[:item_number]
+					BlackStack::Movement.new().parse(bonus, BlackStack::Movement::MOVEMENT_TYPE_ADD_BONUS, 'Payment Bonus', payment_time, item.id).save()
+				}
         #
         DB.disconnect
         GC.start
       }
-    end
+    end # def getPaid
   
     # Verify if I can add this item_number to this invoice.
     # Otherwise, it raise an exception.
@@ -450,10 +494,10 @@ module BlackStack
     # en este caso la factura se genera antes del pago.
     # crea uno o mas registros en la tabla invoice_item.
     def next(i)     
-      b = i.buffer_paypal_notification
-      if b == nil
-        raise "Method BlackStack::Invoice::next requires the previous invoice (i) is linked to a record in the table buffer_paypal_notification."
-      end
+#      b = i.buffer_paypal_notification
+#      if b == nil
+#        raise "Method BlackStack::Invoice::next requires the previous invoice (i) is linked to a record in the table buffer_paypal_notification."
+#      end
   
       id_client = i.id_client
       c = BlackStack::Client.where(:id=>id_client).first
@@ -474,7 +518,8 @@ module BlackStack
       self.create_time = now()
       self.id_client = c.id
       self.id_buffer_paypal_notification = nil
-      self.subscr_id = b.subscr_id
+			self.id_previous_invoice = i.id
+      self.subscr_id = i.subscr_id 
       self.disabled_for_add_remove_items = true
       
       i.items.each { |t| 
@@ -527,17 +572,14 @@ module BlackStack
       # cargo la factura
       i = BlackStack::Invoice.where(:id=>id_invoice).first    
       raise "Invoice not found (#{id_invoice})" if i.nil?
-  
       # obtengo el total de la factura
       total = i.total.to_f
-  
       # Si existe un item, y solo uno, con importe igual al reembolso, entonces se aplica todo el reembolso a ese item. Y termina la funcion.
       # Si existen mas de un item con igual importe que el reembolso, entonces se levanta una excepcion.
       matched_items = i.items.select { |o| o.amount.to_f == -payment_gross.to_f }
-      
+      # 
       if total < -payment_gross
         raise "The refund is higher than the invoice amount (invoice #{id_invoice}, #{total.to_s}, #{payment_gross.to_s})"
-
       # Si el monto del reembolso es igual al total de la factura, se hace un reembolso total de todos los items. Y termina la funcion.
       # Si el monto de la factura es distinto al moneto del reembolso, entonces se levanta una excepcion.
       elsif total == -payment_gross
@@ -555,39 +597,28 @@ module BlackStack
           item1.detail = u.detail.to_s
           item1.description = u.description.to_s
           item1.save()
-          BlackStack::Movement.new().parse(item1, BlackStack::Movement::MOVEMENT_TYPE_REFUND_BALANCE).save()        
+          BlackStack::Movement.new().parse(item1, BlackStack::Movement::MOVEMENT_TYPE_REFUND_BALANCE, 'Full Refund').save()        
+					# si el balance quedo en negativo, entonces aplico otro ajuste
+					net_amount = 0.to_f - BlackStack::Balance.new(self.client.id, u.product_code.to_s).amount.to_f
+					net_credits = 0.to_f - BlackStack::Balance.new(self.client.id, u.product_code.to_s).credits.to_f
+					if net_amount < 0 && net_credits < 0
+						adjust = self.client.adjustment(u.product_code.to_s, net_amount, net_credits, 'Adjustment for Negative Balance after Refund')
+						adjust.id_invoice_item = item1.id
+						adjust.save			
+					end # if net_amount < 0
           # release resources
           DB.disconnect
           GC.start
-        }  
-=begin
-      # si existe al menos un item que coincida el total con el monto del reembolso, 
-      # entonces selecciono el primero 
-      elsif matched_items.size > 0
-        t = matched_items.first
-        h = BlackStack::InvoicingPaymentsProcessing::plans_descriptor.select { |obj| obj[:item_number] == t.item_number }.first
-        raise "Plan not found" if h.nil?
-        item1 = BlackStack::InvoiceItem.new()
-        item1.id = guid()
-        item1.id_invoice = self.id
-        item1.unit_price = t.unit_price.to_f
-        item1.units = -t.units
-        item1.amount = -t.amount.to_f
-        item1.product_code = t.product_code.to_s
-        item1.item_number = t.item_number.to_s
-        item1.detail = t.detail.to_s
-        item1.description = t.description.to_s
-        item1.save()
-        BlackStack::Movement.new().parse(item1, BlackStack::Movement::MOVEMENT_TYPE_REFUND_BALANCE).save()
-=end
+        } # i.items.each { |u|
       # reembolso parcial de una factura con un unico item
       elsif i.items.size == 1
         t = i.items.first
-  
+				# 
         amount = -payment_gross.to_f
         unit_price = t.amount.to_f / t.units.to_f
-        units = (amount / unit_price.to_f).round.to_i
-  
+        float_units = (amount / unit_price.to_f)
+				units = float_units.round.to_i
+				# 
         h = BlackStack::InvoicingPaymentsProcessing::plans_descriptor.select { |obj| obj[:item_number] == t.item_number }.first
         raise "Plan not found" if h.nil?
         item1 = BlackStack::InvoiceItem.new()
@@ -601,13 +632,27 @@ module BlackStack
         item1.detail = t.detail.to_s
         item1.description = t.description.to_s
         item1.save()
-        BlackStack::Movement.new().parse(item1, BlackStack::Movement::MOVEMENT_TYPE_REFUND_BALANCE).save()
-  
+        BlackStack::Movement.new().parse(item1, BlackStack::Movement::MOVEMENT_TYPE_REFUND_BALANCE, 'Partial Refund').save()
+				# agrego un ajuste por el redondeo a una cantidad entera de creditos
+				if float_units.to_f != units.to_f
+					adjustment_amount = unit_price.to_f * (units.to_f - float_units.to_f)
+					adjust = self.client.adjustment(t.product_code.to_s, adjustment_amount, 0, 'Adjustment for Partial Refund', BlackStack::Movement::MOVEMENT_TYPE_REFUND_ADJUSTMENT)
+					adjust.id_invoice_item = item1.id
+					adjust.save
+				end
+				# si el balance quedo en negativo, entonces aplico otro ajuste
+				net_amount = 0.to_f - BlackStack::Balance.new(self.client.id, t.product_code.to_s).amount.to_f
+				net_credits = 0.to_f - BlackStack::Balance.new(self.client.id, t.product_code.to_s).credits.to_f
+				if net_amount < 0 && net_credits < 0
+					adjust = self.client.adjustment(t.product_code.to_s, net_amount, net_credits, 'Adjustment for Negative Balance')
+					adjust.id_invoice_item = item1.id
+					adjust.save			
+				end # if net_amount < 0
+				# recalculo todos los consumos y expiraciones - CANCELADO - Debe hacerse offline
+				# self.client.recalculate(t.product_code.to_s)
       else
         raise "Refund amount is not matching with the invoice total (#{total.to_s}) and the invoice has more than 1 item."
-
       end
-  
       # release resources
       DB.disconnect
       GC.start

data/lib/movement.rb

@@ -10,8 +10,10 @@ module BlackStack
     MOVEMENT_TYPE_ADD_BONUS = 1
     MOVEMENT_TYPE_REASSIGN_BALANCE = 2
     MOVEMENT_TYPE_REFUND_BALANCE = 3
-    MOVEMENT_TYPE_CANCELATION = 4 # liability with the client is reduced due service delivery
-    MOVEMENT_TYPE_EXPIRATION = 5 # liability with the client is reduced due credits expiration
+    MOVEMENT_TYPE_CANCELATION = 4 # liability with the client is reduced due service delivery. it can be recalculated
+    MOVEMENT_TYPE_EXPIRATION = 5 # liability with the client is reduced due credits expiration. it can be recalculated
+		MOVEMENT_TYPE_ADJUSTMENT = 6 # it can be recalculated
+		MOVEMENT_TYPE_REFUND_ADJUSTMENT = 7 # it cannot be recalculated
   
     def typeName()
       if (self.type==MOVEMENT_TYPE_ADD_PAYMENT)
@@ -46,17 +48,20 @@ module BlackStack
     end
     
     # actualiza el registro con los valores del item de una factura
-    # type may be either MOVEMENT_TYPE_ADD_PAYMENT or MOVEMENT_TYPE_ADD_BONUS, but not other value
-    def parse(item, type=MOVEMENT_TYPE_ADD_PAYMENT, description='n/a')
-      plan = BlackStack::InvoicingPaymentsProcessing.plan_descriptor(item.item_number)
+    # type may be either MOVEMENT_TYPE_ADD_PAYMENT or MOVEMENT_TYPE_ADD_BONUS or MOVEMENT_TYPE_REFUND_BALANCE, but not other value
+    def parse(item, type=MOVEMENT_TYPE_ADD_PAYMENT, description='n/a', payment_time=nil, id_item=nil)
+			# the movment must be a payment or a bonus or a refund
+			raise 'Movement must be either a payment or bonus or refund' if type != MOVEMENT_TYPE_ADD_PAYMENT && type != MOVEMENT_TYPE_ADD_BONUS && type != MOVEMENT_TYPE_REFUND_BALANCE
+			# 
+      payment_time = Time.now() if payment_time.nil?
+			plan = BlackStack::InvoicingPaymentsProcessing.plan_descriptor(item.item_number)
       prod = BlackStack::InvoicingPaymentsProcessing.product_descriptor(plan[:product_code])
-
       if (self.id==nil)
         self.id=guid()
       end
       self.id_client = item.invoice.id_client
-      self.id_invoice_item = item.id
-      self.create_time = item.invoice.billing_period_from
+      self.id_invoice_item = id_item.nil? ? item.id : id_item
+      self.create_time = payment_time #item.invoice.billing_period_from
       self.type = type
       if (type != MOVEMENT_TYPE_ADD_BONUS)
         self.paypal1_amount = item.amount.to_f
@@ -70,69 +75,127 @@ module BlackStack
       self.product_code = item.product_code
       self.profits_amount = 0
       self.description = description
-      self.expiration_time = DB["SELECT DATEADD(#{prod[:credits_expiration_period].to_s}#{prod[:credits_expiration_period].to_s}, +#{prod[:credits_expiration_units].to_s}, GETDATE()) AS d"].first[:d].to_s    
+      if (type == MOVEMENT_TYPE_ADD_BONUS || type == MOVEMENT_TYPE_ADD_PAYMENT)
+				self.expiration_time = DB["SELECT DATEADD(#{prod[:credits_expiration_period].to_s}#{prod[:credits_expiration_period].to_s}, +#{prod[:credits_expiration_units].to_s}, '#{payment_time.to_sql}') AS d"].first[:d].to_s
+			end
+			self.expiration_on_next_payment = plan[:expiration_on_next_payment]
+			self.expiration_lead_period = plan[:expiration_lead_period]
+			self.expiration_lead_units = plan[:expiration_lead_units]
+			#self.give_away_negative_credits = plan[:give_away_negative_credits]
       self.save()
+			# recalculate - CANCELADO - SE DEBE HACER OFFLINE
+			#self.recalculate
+			#
+			self
     end
 
-    # Creates a new record in the table movement, as an expiration of the unused credits of this movement.
-    # This movement must be either a payment or a bonus.
-    # This movement must have an expiration time.
-    # The expiraton time of this movement is lower than the current date-time.
-    def expire()
-      m = self
-      p = BlackStack::InvoicingPaymentsProcessing::product_descriptor(m.product_code)
-
-      if m.type != MOVEMENT_TYPE_ADD_PAYMENT && m.type != MOVEMENT_TYPE_ADD_BONUS
-        raise "Movement type mismatch."
-      end
-
-      if m.expiration_time.nil?
-        raise "Expiration time is null."
-      end
-
-      if m.expiration_time >= Time::now()
-        raise "Expiration time is pending."
-      end
+		# Returns the number of credits assigned in the movement that have been consumed.
+		# The movment must be a payment or a bonus
+		def credits_consumed()
+			# the movment must be a payment or a bonus
+			raise 'Movement must be either a payment or a bonus' if self.type != MOVEMENT_TYPE_ADD_PAYMENT && self.type != MOVEMENT_TYPE_ADD_BONUS
+#puts
+#puts "product_code:#{self.product_code}:."
+			# itero los pagos y bonos hechos por este mismo producto, desde el primer dia hasta este movimiento.
+			paid = 0
+			self.client.movements.select { |o| 
+				(o.type == MOVEMENT_TYPE_ADD_PAYMENT || o.type == MOVEMENT_TYPE_ADD_BONUS) &&
+        o.credits.to_f < 0 &&
+        o.product_code.upcase == self.product_code.upcase
+      }.sort_by { |o| o.create_time }.each { |o|
+				paid += (0.to_f - o.credits.to_f)
+				break if o.id.to_guid == self.id.to_guid
+			}
+#puts "paid:#{paid.to_s}:."
+      # calculo los credito para este producto, desde el primer dia; incluyendo cosumo, expiraciones, ajustes.
+      consumed = self.client.movements.select { |o| 
+        o.credits.to_f > 0 &&
+        o.product_code.upcase == self.product_code.upcase
+      }.inject(0) { |sum, o| sum.to_f + o.credits.to_f }.to_f
+#puts "consumed:#{consumed.to_s}:."			
+      # calculo los creditos de este movimiento que voy a cancelar
+      credits = 0.to_f - self.credits.to_f
+#puts "credits:#{credits.to_s}:."
+			# 
+			if paid - consumed <= 0 # # se consumio todo
+#puts "a"
+				return credits 
+			else # paid - consumed > 0 # todavia no se consumio todo
+				if paid - consumed > credits # todavia se estan consumiendo creditos de los pagos anteriores
+#puts "b"
+					return 0
+				else # paid - consumed >= credits # se consumio una parte del credito
+#puts "c"
+					n = credits >= (paid - consumed) ? credits - (paid - consumed) : credits
+#puts "n:#{n.to_s}:."
+					return n
+				end
+			end
+		end
 
-      if m.expiration_time <= m.create_time
-        raise "Expiration time is lower then creation time."
-      end
-      
-      # calculo cuantos creditos tiene este cliente
-      x = 0.to_f - BlackStack::Balance.new(m.client.id, p[:code]).credits.to_f
+		# returns the real expiration based on expiration_time, expiration_lead_period and expiration_lead_units
+		def expiration_lead_time()
+			return nil if self.expiration_time.nil?
+			return self.expiration_time if self.expiration_lead_period.nil? || self.expiration_lead_units.nil?
+			if self.expiration_lead_period == 'H' # hours
+				return self.expiration_time + self.expiration_lead_units.to_i * 60*60
+			elsif self.expiration_lead_period == 'D' # days
+				return self.expiration_time + self.expiration_lead_units.to_i * 24*60*60
+			elsif self.expiration_lead_period == 'W' # weeks
+				return self.expiration_time + self.expiration_lead_units.to_i * 7*24*60*60
+			elsif self.expiration_lead_period == 'M' # months
+				return self.expiration_time + self.expiration_lead_units.to_i * 31*24*60*60
+			elsif self.expiration_lead_period == 'Y' # years
+				return self.expiration_time + self.expiration_lead_units.to_i * 366*24*60*60
+			else
+				return self.expiration_time
+			end
+		end
 
-      # calculo el credito adquirido luego de este movimiento que voy a cancelar
-      y = m.client.movements.select { |o| 
-        (
-          o.type == BlackStack::Movement::MOVEMENT_TYPE_ADD_PAYMENT || 
-          o.type == BlackStack::Movement::MOVEMENT_TYPE_ADD_BONUS
-        ) &&
-        o.product_code.upcase == p[:code].upcase && 
-        o.create_time > m.create_time 
-      }.inject(0) { |sum, o| sum.to_f + (0.to_f - o.credits.to_f) }.to_f
+		# credits expiration
+		def expire()
+			credits_consumed = self.credits_consumed
+			# 
+			self.expiration_start_time = now()
+			self.expiration_tries = self.expiration_tries.to_i + 1
+			self.save
+			# 
+			total_credits = 0.to_f - BlackStack::Balance.new(self.client.id, self.product_code).credits.to_f
+			total_amount = 0.to_f - BlackStack::Balance.new(self.client.id, self.product_code).amount.to_f
+			#
+			credits = 0.to_i - self.credits.to_i
+			#
+			credits_to_expire = credits - credits_consumed.to_i #- (0.to_f - self.credits.to_f)).to_i
+			amount_to_expire = total_credits.to_f == 0 ? 0 : credits_to_expire.to_f * ( total_amount.to_f / total_credits.to_f )
+			#
+			exp = BlackStack::Movement.new
+			exp.id = guid()
+			exp.id_client = self.client.id
+			exp.create_time = now()
+			exp.type = BlackStack::Movement::MOVEMENT_TYPE_EXPIRATION
+			exp.id_user_creator = self.id_user_creator
+			exp.description = 'Expiration Because Allocation is Renewed'
+			exp.paypal1_amount = 0
+			exp.bonus_amount = 0
+			exp.amount = amount_to_expire
+			exp.credits = credits_to_expire
+			exp.profits_amount = -amount_to_expire
+			exp.id_invoice_item = self.id_invoice_item
+			exp.product_code = self.product_code
+			exp.save
+			# 
+			self.expiration_end_time = now()
+			self.save
+		end # def expire
 
-      # calculo el # de creditos no usados de este movimiento que ha expirado
-      z = x-y>0 ? x-y : 0 
+		# recalculate the amount for all the consumptions.
+		# The movment must be a payment or a bonus or refund
+		def recalculate()
+			# the movment must be a payment or a bonus or a refund
+			raise 'Movement must be either a payment or bonus or refund' if type != MOVEMENT_TYPE_ADD_PAYMENT && type != MOVEMENT_TYPE_ADD_BONUS && type != MOVEMENT_TYPE_REFUND_BALANCE
+			# recalculate amounts for all the consumptions and expirations
+			self.client.recalculate(self.product_code)
+		end 
 
-      # si el monto expirado es positivo, entonces registro
-      # una cancelacion de saldo
-      if z>0
-        amount = ( m.amount.to_f / m.credits.to_f ) * z.to_f              
-        m = BlackStack::Movement.new(
-          :id_client => m.client.id,
-          :create_time => now(),
-          :type => BlackStack::Movement::MOVEMENT_TYPE_EXPIRATION,
-          :description => "Expiration of #{m.id.to_guid}",
-          :paypal1_amount => 0,
-          :bonus_amount => 0,
-          :amount => amount,
-          :credits => z,
-          :profits_amount => -amount,
-          :product_code => p[:code],
-        )
-        m.id = guid()
-        m.save
-      end # z>0
-    end # def expire
   end # class Movement
 end # module BlackStack

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invoicing_payments_processing
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.14
 platform: ruby
 authors:
 - Leandro Daniel Sardi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-09 00:00:00.000000000 Z
+date: 2020-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket