africompta 1.9.10 → 1.9.11

data/lib/africompta/acqooxview.rb

@@ -5,15 +5,15 @@
 require 'digest/md5'
 
 # We want a simple time-print
-class Time
-  def to_s
-    day.to_s + '/' + month.to_s
-  end
-
-  def to_ss
-    to_s + '/' + year.to_s
-  end
-end
+# class Time
+#   def to_s
+#     day.to_s + '/' + month.to_s
+#   end
+#
+#   def to_ss
+#     to_s + '/' + year.to_s
+#   end
+# end
 
 class Date
   def month_s
@@ -67,7 +67,7 @@ class Float
 end
 
 module ACQooxView
-  def self.load_entities(preload = true)
+  def self.load_entities_old(preload = true)
     require 'africompta/acaccess'
     Dir[File.dirname(__FILE__) + '/entities/*.rb'].each { |f|
       dputs(2) { "Adding #{f}" }

data/lib/africompta/entities/account.rb

@@ -1,106 +1,6 @@
 require 'prawn'
 require 'prawn/measurement_extensions'
 
-class AccountRoot
-
-  def self.actual
-    self.accounts.find { |a| a.name == 'Root' }
-  end
-
-  def self.current
-    AccountRoot.actual
-  end
-
-  def self.archive
-    self.accounts.find { |a| a.name == 'Archive' }
-  end
-
-  def self.accounts
-    Accounts.matches_by_account_id(0)
-  end
-
-  def self.clean
-    count_mov, count_acc = 0, 0
-    bad_mov, bad_acc = 0, 0
-    log_msg 'Account.clean', 'starting to clean up'
-    Movements.search_all_.each { |m|
-      dputs(4) { "Testing movement #{m.inspect}" }
-      if not m or not m.date or not m.desc or not m.value or
-          not m.rev_index or not m.account_src or not m.account_dst
-        if m and m.desc
-          log_msg 'Account.clean', "Bad movement: #{m.inspect}"
-        end
-        m.delete
-        bad_mov += 1
-      end
-      if m.rev_index
-        count_mov = [count_mov, m.rev_index].max
-      end
-    }
-    Accounts.search_all_.each { |a|
-      if (a.account_id and (a.account_id > 0)) and (not a.account)
-        log_msg 'Account.clean', "Account has unexistent parent: #{a.inspect}"
-        a.delete
-        bad_acc += 1
-      end
-      if !(a.account_id or a.deleted)
-        log_msg 'Account.clean', "Account has undefined parent: #{a.inspect}"
-        a.delete
-        bad_acc += 1
-      end
-      if a.account_id == 0
-        if !((a.name =~ /(Root|Archive)/) or a.deleted)
-          log_msg 'Account.clean', 'Account is in root but neither ' +
-                                     "'Root' nor 'Archive': #{a.inspect}"
-          a.delete
-          bad_acc += 1
-        end
-      end
-      if !a.rev_index
-        log_msg 'Account.clean', "Didn't find rev_index for #{a.inspect}"
-        a.new_index
-        bad_acc += 1
-      end
-      count_acc = [count_acc, a.rev_index].max
-    }
-
-    # Check also whether our counters are OK
-    u_l = Users.match_by_name('local')
-    dputs(1) { "Movements-index: #{count_mov} - #{u_l.movement_index}" }
-    dputs(1) { "Accounts-index: #{count_acc} - #{u_l.account_index}" }
-    @ul_mov, @ul_acc = u_l.movement_index, u_l.account_index
-    if count_mov > u_l.movement_index
-      log_msg 'Account.clean', 'Error, there is a bigger movement! Fixing'
-      u_l.movement_index = count_mov + 1
-    end
-    if count_acc > u_l.account_index
-      log_msg 'Account.clean', 'Error, there is a bigger account! Fixing'
-      u_l.account_index = count_acc + 1
-    end
-    return [count_mov, bad_mov, count_acc, bad_acc]
-  end
-
-  def self.path_id
-    return ''
-  end
-
-  def self.id
-    0
-  end
-
-  def self.mult
-    1
-  end
-
-  def self.keep_total
-    false
-  end
-
-  def self.multiplier
-    1
-  end
-end
-
 class Accounts < Entities
   self.needs %w(Users Movements)
 
@@ -126,7 +26,7 @@ class Accounts < Entities
   def self.create(name, desc = 'Too lazy', parent = nil, global_id = '', mult = nil)
     dputs(5) { "Parent is #{parent.inspect}" }
     if parent
-      if parent.class != Account and parent != AccountRoot
+      if parent.class != Account && parent != AccountRoot
         parent = Accounts.matches_by_id(parent).first
       end
       mult ||= parent.multiplier
@@ -539,20 +439,24 @@ class Accounts < Entities
     }
   end
 
+  def init
+    root = Accounts.create('Root', 'Initialisation')
+    %w( Income Outcome Lending Cash ).each { |a|
+      Accounts.create(a, 'Initialisation', root)
+    }
+    %w( Lending Cash ).each { |a|
+      acc = Accounts.match_by_name(a)
+      acc.multiplier = -1
+      acc.keep_total = true
+    }
+    Accounts.save
+  end
+
   def load
     super
     if Accounts.search_by_name('Root').count == 0
-      dputs(1) { "Didn't find 'Root' in database - creating base" }
-      root = Accounts.create('Root', 'Initialisation')
-      %w( Income Outcome Lending Cash ).each { |a|
-        Accounts.create(a, 'Initialisation', root)
-      }
-      %w( Lending Cash ).each { |a|
-        acc = Accounts.match_by_name(a)
-        acc.multiplier = -1
-        acc.keep_total = true
-      }
-      Accounts.save
+      dputs(0) { "Didn't find 'Root' in database - creating base" }
+      Accounts.init
     end
   end
 
@@ -652,12 +556,112 @@ class Accounts < Entities
   end
 end
 
+class AccountRoot
+
+  def self.actual
+    self.accounts.find { |a| a.name == 'Root' }
+  end
+
+  def self.current
+    AccountRoot.actual
+  end
+
+  def self.archive
+    self.accounts.find { |a| a.name == 'Archive' }
+  end
+
+  def self.accounts
+    Accounts.matches_by_account_id(0)
+  end
+
+  def self.clean
+    count_mov, count_acc = 0, 0
+    bad_mov, bad_acc = 0, 0
+    log_msg 'Account.clean', 'starting to clean up'
+    Movements.search_all_.each { |m|
+      dputs(4) { "Testing movement #{m.inspect}" }
+      if not m or not m.date or not m.desc or not m.value or
+          not m.rev_index or not m.account_src or not m.account_dst
+        if m and m.desc
+          log_msg 'Account.clean', "Bad movement: #{m.inspect}"
+        end
+        m.delete
+        bad_mov += 1
+      end
+      if m.rev_index
+        count_mov = [count_mov, m.rev_index].max
+      end
+    }
+    Accounts.search_all_.each { |a|
+      if (a.account_id && (a.account_id > 0)) && (!a.account)
+        log_msg 'Account.clean', "Account has unexistent parent: #{a.inspect}"
+        a.delete
+        bad_acc += 1
+      end
+      if !(a.account_id || a.deleted)
+        log_msg 'Account.clean', "Account has undefined parent: #{a.inspect}"
+        a.delete
+        bad_acc += 1
+      end
+      if a.account_id == 0 || a.account_id == nil
+        if !((a.name =~ /(Root|Archive)/) || a.deleted)
+          log_msg 'Account.clean', 'Account is in root but neither ' +
+                                     "'Root' nor 'Archive': #{a.inspect}"
+          a.delete
+          bad_acc += 1
+        end
+      end
+      if !a.rev_index
+        log_msg 'Account.clean', "Didn't find rev_index for #{a.inspect}"
+        a.new_index
+        bad_acc += 1
+      end
+      count_acc = [count_acc, a.rev_index].max
+    }
+
+    # Check also whether our counters are OK
+    u_l = Users.match_by_name('local')
+    dputs(1) { "Movements-index: #{count_mov} - #{u_l.movement_index}" }
+    dputs(1) { "Accounts-index: #{count_acc} - #{u_l.account_index}" }
+    @ul_mov, @ul_acc = u_l.movement_index, u_l.account_index
+    if count_mov > u_l.movement_index
+      log_msg 'Account.clean', 'Error, there is a bigger movement! Fixing'
+      u_l.movement_index = count_mov + 1
+    end
+    if count_acc > u_l.account_index
+      log_msg 'Account.clean', 'Error, there is a bigger account! Fixing'
+      u_l.account_index = count_acc + 1
+    end
+    return [count_mov, bad_mov, count_acc, bad_acc]
+  end
+
+  def self.path_id
+    return ''
+  end
+
+  def self.id
+    0
+  end
+
+  def self.mult
+    1
+  end
+
+  def self.keep_total
+    false
+  end
+
+  def self.multiplier
+    1
+  end
+end
+
 class Account < Entity
 
   def data_set(f, v)
     if !@proxy.loading
-      if !%w( _total _rev_index ).index(f.to_s)
-        dputs(4) { "Updating index for field #{f.inspect} - #{@pre_init} - #{@proxy.loading} - #{caller}" }
+      if !%w( _total _rev_index _global_id ).index(f.to_s)
+        dputs(4) { "Updating index for field #{f.inspect} - #{@pre_init} - #{@proxy.loading}: #{v}" }
         new_index
       end
     end
@@ -714,7 +718,7 @@ class Account < Entity
     end
     self.rev_index = u_l.account_index
     u_l.account_index += 1
-    dputs(3) { "Index for account #{name} is #{index}" }
+    dputs(3) { "Index for account #{name} is #{rev_index}" }
   end
 
   def update_total(precision = 3)
@@ -874,7 +878,7 @@ class Account < Entity
   end
 
   def delete(force = false)
-    if not is_empty and force
+    if not is_empty && force
       movements_src.each { |m|
         dputs(3) { "Deleting movement #{m.to_json}" }
         m.delete

data/lib/africompta/entities/config_base.rb

@@ -0,0 +1,9 @@
+class ConfigBases < Entities
+  def add_config
+    value_block :vars_narrow
+
+    value_block :vars_wide
+
+    @@functions = %i( accounting accounting_standalone )
+  end
+end

data/lib/africompta/entities/remote.rb

@@ -1,12 +1,12 @@
 class Remotes < Entities
-	
-  def create( d )
-    r = super( d )
-    d.has_key?( :account_index ) || r.account_index = 0
-    d.has_key?( :movement_index ) || r.movement_index = 0
+
+  def create(d)
+    r = super(d)
+    d.has_key?(:account_index) || r.account_index = 0
+    d.has_key?(:movement_index) || r.movement_index = 0
     r
   end
-	
+
   def setup_data
     value_str :url
     value_str :name
@@ -14,9 +14,59 @@ class Remotes < Entities
     value_int :account_index
     value_int :movement_index
   end
+
+  def self.get_db(url, name, pass)
+    vers = Net::HTTP.get(URI.parse("#{url}/merge/version/#{name},#{pass}"))
+    if vers != $VERSION.to_s
+      return (vers =~ /not known/) ? 'User and/or password wrong' : 'Version mismatch'
+    end
+
+    db = Net::HTTP.get(URI.parse("#{url}/merge/get_db/#{name},#{pass}"))
+
+    SQLite.dbs_close_all
+    # All accounting-stuff is stored in the same database
+    IO.write(Accounts.storage[:SQLiteAC].db_file, db)
+    IO.write('/tmp/compta.db', db)
+    SQLite.dbs_open_load_migrate
+
+    # Delete all users except for the 'local' who needs a new id
+    Users.search_all_.each { |u|
+      if u.name == 'local'
+        u.reset_id
+      else
+        u.delete
+      end
+    }
+
+    # Delete all other remotes and add ourselves
+    Remotes.search_all_.each { |r| r.delete }
+    remote = Remotes.create(url: url, name: name, pass: pass)
+
+    # Update all indexes
+    ret = remote.do_copied
+    if ret == true
+      remote
+    else
+      ret
+    end
+  end
 end
 
 class Remote < Entity
+  attr_reader :step, :got_accounts, :put_accounts, :got_movements,
+              :put_movements, :put_movements_changes
+
+  def setup_instance
+    u = Users.find_by_name('local')
+    @step = 'preparation'
+    @account_index_stop, @movement_index_stop,
+        @got_accounts, @put_accounts,
+        @got_movements, @put_movements, @put_movements_changes =
+        [0] * 7
+    @account_index_stop = u.account_index - 1
+    @movement_index_stop = u.movement_index - 1
+  end
+
   def update_movement_index
     self.movement_index = Users.match_by_name('local').movement_index - 1
   end
@@ -24,4 +74,188 @@ class Remote < Entity
   def update_account_index
     self.account_index = Users.match_by_name('local').account_index - 1
   end
+
+  def post_form(path, hash)
+    dputs(4) { "Starting postForm with path #{path}" }
+    Net::HTTP.post_form(URI.parse(url + "/merge/#{path}"),
+                        {'user' => name, 'pass' => pass}.merge(hash))
+    dputs(4) { "Ending postForm with path #{path}" }
+  end
+
+  def get_form(path)
+    url_parsed = URI.parse(url)
+    dputs(4) { "Starting getForm with path #{path} - #{url_parsed.inspect}" }
+    dputs(4) { "Finished parsing #{url}" }
+    ret = Net::HTTP.get(url_parsed.host, "#{url_parsed.path}/merge/#{path}/#{name},#{pass}", url_parsed.port)
+    dputs(4) { "Ending getForm with path #{path}" }
+    ret
+  end
+
+  # Calls the remote end and searches for new accounts and movements
+  # on both sides. Steps:
+  # 0: check version
+  # 1: get remote accounts
+  # 2: send our accounts
+  # 3: get remote movements
+  # 4: send our movements
+  # 5: update the indexes
+  # The variable +step+ can be used to watch the progress if it is called
+  # in a thread
+  def do_merge
+    setup_instance
+
+    u = Users.find_by_name('local')
+    log_msg :Merging, "Starting to merge for #{url}"
+
+    @step = 'checking remote'
+    begin
+      check_version
+    rescue StandardError => e
+      @step = "done - error: #{e.to_s}"
+      return
+    end
+
+    @step = 'getting remote accounts'
+    get_remote_accounts
+
+    @step = 'sending our accounts'
+    send_accounts
+
+    @step = 'getting remote movements'
+    get_remote_movements
+
+    @step = 'sending movements'
+    send_movements
+
+    @step = 'updating all indexes'
+    # Update the pointer
+    update_movement_index
+    # Update the remote pointers
+    get_form('reset_user_indexes')
+
+    @step = 'done'
+  end
+
+  def check_version(show_error = true)
+    local_id = Users.find_by_name('local').full
+    dputs(2) { "Local id is: #{local_id}" }
+    if (local_id == get_form('local_id'))
+      show_error and dputs(0) { 'Both locals have same ID' }
+      raise 'Same ID for local'
+    end
+
+    # Check the versions
+    if (vers = get_form('version')) != $VERSION.to_s
+      if (vers =~ /not known/)
+        show_error and dputs(0) { 'Username / password not recognized' }
+        raise 'Wrong credentials'
+      else
+        show_error and dputs(0) { "Got version #{vers} instead of #{$VERSION.to_s}" }
+        raise 'Wrong version'
+      end
+    end
+    return true
+  end
+
+  def get_remote_accounts
+    dputs(2) { 'Getting remotes' }
+    accounts = get_form('accounts_get')
+    accounts.split("\n").each { |a|
+      acc = Accounts.from_s(a)
+      dputs(2) { "Got account #{acc.name}" }
+      @got_accounts += 1
+    }
+  end
+
+  def send_accounts
+    @account_index_start = account_index.to_i + 1
+    if @account_index_start <= @account_index_stop
+      dputs(1) { "Accounts to send: #{@account_index_start}..#{@account_index_stop}" }
+      # Just search all accounts for indexes and sort them
+      Accounts.data.select { |k, v|
+        v._rev_index.between?(@account_index_start, @account_index_stop)
+      }.collect { |k, v| Accounts.get_data_instance(k) }.
+          sort_by { |a| a.rev_index }.each { |acc|
+        dputs(2) { "Account with index #{acc.rev_index} is being transferred" }
+        post_form('account_put', {'account' => acc.to_s})
+        @put_accounts += 1
+
+      }
+    else
+      dputs(1) { 'No accounts to send' }
+    end
+    # Update the pointer
+    update_account_index
+  end
+
+  def get_remote_movements
+    dputs(1) { 'Getting movements' }
+    # Now merge the movements
+    movements = get_form('movements_get')
+    movements.split("\n").each { |m|
+      dputs(2) { "String is: \n#{m}" }
+      mov = Movements.from_s(m)
+      @got_movements += 1
+    }
+  end
+
+  def send_movements
+    #dputs_func
+    @movement_index_start = movement_index.to_i + 1
+    @movement_count = 0
+    if @movement_index_start <= @movement_index_stop
+      dputs(1) { "Movements to send: #{@movement_index_start}.." +
+          "#{@movement_index_stop}" }
+      movements = []
+      Movements.data.select { |k, v| v._rev_index.between?(
+          @movement_index_start, @movement_index_stop
+      ) }.each { |k, v|
+        m = Movements.get_data_instance(k)
+        movements.push(m.to_json)
+        @put_movements += 1
+      }
+      @movement_count = movements.size
+      dputs(1) { "Having #{movements.size} movements to send" }
+      while movements.size > 0
+        # We'll do it by bunches of 10
+        movements_put = movements.shift 10
+        dputs(1) { 'Putting one bunch of 10 movements' }
+        dputs(4) { movements_put.to_json }
+        post_form('movements_put', {'movements' => movements_put.to_json})
+        @put_movements_changes += 1
+        # TODO: remove
+        # movements = []
+      end
+    else
+      dputs(1) { 'No movements to send' }
+    end
+  end
+
+  # Is used to reset the pointers, supposes both databases are equal -
+  # Should probably be used with care
+  def do_copied
+    check_version
+
+    # Update local indexes
+    u = Users.find_by_name('local')
+    update_account_index
+    update_movement_index
+
+    # Update remote indexes
+    get_form('reset_user_indexes')
+
+    # Check if everything is OK
+    acc, mov = get_form('index').split(',')
+
+    if acc.to_i != u.account_index
+      dputs(0) { "Trying to do 'copied' with wrong account-indexes" }
+      dputs(0) { "#{acc.to_i} - #{u.account_index}" }
+    end
+    if mov.to_i != u.movement_index
+      dputs(0) { "Trying to do 'copied' with wrong movement-indexes" }
+      dputs(0) { "#{mov.to_i} - #{u.movement_index}" }
+    end
+
+    return true
+  end
 end