africompta 1.9.8

data/lib/africompta/entities/acschemas.rb

@@ -0,0 +1,16 @@
+class Schema_Infos < Entities
+  def setup_data
+    @default_type = :SQLiteAC
+    @data_field_id = :id
+    
+    value_str :version
+  end
+
+  def migration_1(s)
+    s.version = '0.4'
+  end
+
+  def migration_2(s)
+    s.version = '0.5'
+  end
+end

data/lib/africompta/entities/movement.rb

@@ -0,0 +1,292 @@
+DEBUG_SLOW=4
+class Movements < Entities
+  attr_reader :check_state, :check_progress
+
+  def setup_data
+    @default_type = :SQLiteAC
+    @data_field_id = :id
+    value_int :index
+
+    value_entity_account :account_src_id
+    value_entity_account :account_dst_id
+    value_float :value
+    value_str :desc
+    value_date :date
+    value_int :revision
+    value_str :global_id
+    value_int :rev_index
+  end
+
+  def migration_1(m)
+    dputs(1) { "Migrating #{m.id}" }
+    m.rev_index = m.id
+  end
+
+  def self.from_json(str)
+    self.from_s(ActiveSupport::JSON.decode(str)['str'])
+  end
+
+  def self.get_accounts(src, dst)
+    [Accounts.match_by_global_id(src), Accounts.match_by_global_id(dst)]
+  end
+
+  def self.mbgi(global_id)
+    self.match_by_global_id(global_id)
+  end
+
+  def self.from_s(str)
+    str.force_encoding(Encoding::UTF_8)
+    dputs(3) { "Getting movement from #{str.inspect}" }
+    desc, str = str.split("\r")
+    global_id, value, date, src, dst = str.split("\t")
+    #date = Time.parse(date).to_ss
+    date = Date.strptime(date, '%Y-%m-%d')
+    value = value.to_f
+    a_src, a_dst = self.get_accounts(src, dst)
+    if not a_src or not a_dst
+      dputs(0) { "Couldn't parse #{str.inspect}: " +
+          (a_src ? '' : "account #{src} not found. ") +
+          (a_dst ? '' : "account #{dst} not found") }
+      return nil
+    end
+    # Does the movement already exist?
+    dputs(DEBUG_SLOW) { 'from_s 1'
+    }
+    our_m = nil
+    if not (our_m = self.mbgi(global_id))
+      dputs(3) { 'New movement' }
+      our_m = self.create(desc, date, value,
+                          a_src, a_dst)
+      dputs(DEBUG_SLOW) { 'from_s 2' }
+      our_m.global_id = global_id
+    else
+      dputs(1) { "Overwriting movement\n#{our_m.to_json.inspect} with" }
+      # And update it
+      our_m.set(desc, date, value, a_src.id, a_dst.id)
+      dputs(1) { "#{our_m.to_json.inspect}" }
+      dputs(2) { "Now we're #{our_m.rev_index}:#{our_m.id} -> #{global_id}" }
+    end
+    dputs(DEBUG_SLOW) { 'from_s 3' }
+    return our_m
+  end
+
+  def create(desc, date, value, source, dest)
+    return nil if source == dest
+    dputs(DEBUG_SLOW) { 'create - 1' }
+    if date.class == String
+      date = Date.strptime(date, '%Y-%m-%d')
+    end
+    t = super(:desc => desc, :date => date,
+              :value => 0, :account_src_id => source.id, :account_dst_id => dest.id)
+    dputs(DEBUG_SLOW) { 'create - 2' }
+    t.value = value
+    dputs(DEBUG_SLOW) { 'create - 3' }
+    t.global_id = Users.match_by_name('local').full + '-' + t.id.to_s
+    dputs(DEBUG_SLOW) { 'create - 4' }
+    dputs(1) { "Created #{t.to_json.inspect}" }
+    t
+  end
+
+  def search_index_range(from, to)
+    @data.select { |k, v|
+      v._rev_index && v._rev_index >= from && v._rev_index <= to
+    }.map { |k, v|
+      get_data_instance(k)
+    }
+  end
+
+  def get_account(db, id)
+    db.execute("select * from compta_accounts where id=#{id}").first[4]
+  end
+
+  def check_against_db(file)
+    # First build
+    # in_db - content of 'file' in .to_s format
+    # in_local - content available locally in .to_s format
+    in_db, diff, in_local = [], [], []
+
+    dputs(3) { 'Searching all movements' }
+    @check_state = 'Collect local'
+    @check_progress = 0.0
+    in_local = Movements.search_all_.reject { |m| m.value.to_f.round(3) == 0.0 }
+    progress_step = 1.0 / (in_local.size + 1)
+    dputs(3) { "Movements total: #{in_local.size}" }
+
+    @check_state = 'Collect local'
+    in_local = in_local.collect { |a|
+      @check_progress += progress_step
+      a.to_s
+    }
+
+    dputs(3) { 'Going to check all movements' }
+    @check_state = 'Collect file-DB'
+    @check_progress = 0.0
+    SQLite3::Database.new(file) do |db|
+      db.execute('select id, desc, global_id, value, date, account_src_id, account_dst_id '+
+                     'from compta_movements').each do |row|
+        @check_progress += progress_step
+        #dputs(3) { "Looking at #{row}" }
+
+        id_, desc_, gid_, value_, date_, src_, dst_ = row
+        if value_.to_f.round(3) != 0.0
+          in_db.push "#{desc_}\r#{gid_}\t" +
+                         "#{sprintf('%.3f', value_.to_f.round(3))}\t#{date_.to_s}\t"+
+                         "#{get_account(db, src_)}\t#{get_account(db, dst_)}"
+        end
+      end
+    end
+
+    # Now compare what is available only in db and what is available only locally
+    dputs(3) { 'Verifying movements on one side only' }
+    @check_state = 'On one side'
+    @check_progress = 0.0
+    in_db.delete_if { |a|
+      @check_progress += progress_step
+      in_local.delete(a)
+    }
+
+    # And search for accounts with same global-id but different content
+    dputs(3) { 'Verifying mixed-up movements' }
+    (in_db + in_local).sort_by { |a| a.match(/\r(.*?)\t/)[1] }
+    @check_state = 'Mixed-up'
+    @check_progress = 0.0
+    progress_step = 1.0 / (in_db.size + 1)
+    in_db.delete_if { |a|
+      @check_progress += progress_step
+      gid = a.match(/\r(.*?)\t/)[1]
+      if c = in_local.find { |b| b =~ /\r#{gid}\t/ }
+        diff.push [a, c]
+        in_local.delete c
+      end
+    }
+
+    @check_state = 'Done'
+    [in_db, diff, in_local]
+  end
+
+end
+
+
+class Movement < Entity
+
+  def init_instance
+  end
+
+  def data_set(f, v)
+    if f != :_rev_index
+      dputs(3){"Updating index for field #{f.inspect}"}
+      new_index
+    end
+    super(f, v)
+  end
+
+  def new_index
+    u_l = Users.match_by_name('local')
+    self.rev_index = u_l.movement_index.to_i
+    u_l.movement_index = self.rev_index + 1
+    dputs(3) { "index is #{self.rev_index} and date is --#{self.date}--" }
+    dputs(3) { "User('local').rev_index is: " + Users.match_by_name('local').movement_index.to_s }
+  end
+
+  def get_index
+    return self.rev_index
+  end
+
+  def is_in_account(a)
+    return (a == account_src or a == account_dst)
+  end
+
+  def value=(v)
+    if account_src and account_dst
+      dputs(3) { 'value=' + v.to_s + ':' + account_src.total.to_s }
+      diff = value.to_f - v.to_f
+      account_src.total = account_src.total.to_f + (diff * account_src.multiplier)
+      account_dst.total = account_dst.total.to_f - (diff * account_dst.multiplier)
+    end
+    data_set(:_value, v)
+  end
+
+  def get_value(account)
+    account_side = (account_src == account ? -1 : 1)
+    dputs(5) { "account_src #{account_src.inspect} == account #{account.inspect}" }
+    dputs(5) { "Account_side = #{account_side}" }
+    value.to_f * account.multiplier.to_f * account_side
+  end
+
+  def get_other_account(account)
+    account_src == account ? account_dst : account_src
+  end
+
+  def move_from_to(from, to)
+    v = self.value
+    self.value = 0
+    if account_src_id == from
+      self.account_src_id = to
+    end
+    if account_dst_id == from
+      self.account_dst_id = to
+    end
+    self.value = v
+  end
+
+  def set(desc, date, value, source, dest)
+    dputs(3) { 'self.value ' + self.value.to_s + ' - ' + value.to_s }
+    self.value = 0
+    self.account_src_id, self.account_dst_id = source, dest
+    if false
+      # Do some date-magic, so that we can give either the day, day and month or
+      # a complete date. The rest is filled up with todays date.
+      date = date.split('/')
+      da = Date.today
+      d = [da.day, da.month, da.year]
+      date += d.last(3 - date.size)
+      if date[2].to_s.size > 2
+        self.date = Date.strptime(date.join('/'), '%d/%m/%Y')
+      else
+        self.date = Date.strptime(date.join('/'), '%d/%m/%y')
+      end
+    else
+      self.date = Date.from_s(date.to_s)
+    end
+    self.desc, self.value = desc, value
+    dputs(DEBUG_SLOW) { 'Getting new index' }
+    self.new_index
+    dputs(DEBUG_SLOW) { 'Date ' + self.date.to_s }
+  end
+
+  def to_s
+    dputs(5) { "I am: #{to_hash.inspect} - my id is: #{global_id}" }
+    "#{desc}\r#{global_id}\t" +
+        "#{sprintf('%.3f', value.to_f.round(3))}\t#{date.to_s}\t" +
+        account_src.global_id.to_s + "\t" +
+        account_dst.global_id.to_s
+  end
+
+  def to_json
+    ActiveSupport::JSON.encode(:str => to_s)
+  end
+
+  # Copying over data from old AfriCompta
+  def account_src
+    account_src_id
+  end
+
+  def account_dst
+    account_dst_id
+  end
+
+  def delete
+    dputs(DEBUG_SLOW) { "Deleting movement #{desc}" }
+    src, dst = account_src, account_dst
+    dputs(3) { "totals before: #{src.get_path}=#{src.total}, " +
+        "#{dst.get_path}=#{dst.total}" }
+    self.value = 0
+    dputs(3) { "totals after: #{src.get_path}=#{src.total}, " +
+        "#{dst.get_path}=#{dst.total}" }
+    super
+  end
+
+  def value_form
+    Account.total_form(value)
+  end
+end

data/lib/africompta/entities/remote.rb

@@ -0,0 +1,27 @@
+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
+    r
+  end
+	
+  def setup_data
+    value_str :url
+    value_str :name
+    value_str :pass
+    value_int :account_index
+    value_int :movement_index
+  end
+end
+
+class Remote < Entity
+  def update_movement_index
+    self.movement_index = Users.match_by_name('local').movement_index - 1
+  end
+
+  def update_account_index
+    self.account_index = Users.match_by_name('local').account_index - 1
+  end
+end

data/lib/africompta/entities/users.rb

@@ -0,0 +1,55 @@
+class Users < Entities
+
+  def setup_data
+    @default_type = :SQLiteAC
+    @data_field_id = :id
+
+    value_str :name
+    value_str :full
+    value_str :pass
+    #value_array :accounts
+    # The last account_index that got transmitted
+    value_int :account_index
+    # The last movement_index that got transmitted
+    value_int :movement_index
+  end
+
+  def load
+    super
+    if Users.search_by_name('local').count == 0
+      user = Users.create('local', Digest::MD5.hexdigest((rand 2**128).to_s).to_s,
+                          rand(2 ** 128).to_s)
+      dputs(1) { "Created local user #{user}" }
+    end
+  end
+
+  def migration_1(u)
+    u.account_index ||= 0
+    u.movement_index ||= 0
+  end
+
+  def create(name, full = nil, pass = nil)
+    if not full or not pass
+      dputs(2) { "Creating with hash: #{name.inspect}" }
+      name, full, pass = name[:name], name[:full], name[:pass]
+    end
+    new_user = super(:name => name, :full => full, :pass => pass)
+    new_user.account_index, new_user.movement_index = 0, 0
+    new_user
+  end
+end
+
+class User < Entity
+  def update_movement_index
+    self.movement_index = Users.match_by_name('local').movement_index - 1
+  end
+
+  def update_account_index
+    self.account_index = Users.match_by_name('local').account_index - 1
+  end
+
+  def update_all
+    update_movement_index
+    update_account_index
+  end
+end

data/lib/africompta/views/edit/movement.rb

@@ -0,0 +1,8 @@
+
+class EditMovements < View
+  def layout
+    gui_vbox do
+      show_str :movement
+    end
+  end
+end

data/lib/africompta/views/edit/tabs.rb

@@ -0,0 +1,8 @@
+
+class EditTabs < View
+  def layout
+    gui_vbox do
+      show_str :edit
+    end
+  end
+end

data/lib/africompta/views/report/annual.rb

@@ -0,0 +1,3 @@
+class ReportAnnual < View
+  
+end

data/lib/africompta/views/report/tabs.rb

@@ -0,0 +1,3 @@
+class ReportTabs < View
+  
+end

data/lib/africompta.rb

@@ -0,0 +1,2 @@
+require 'bundler/setup'
+require 'africompta/africompta'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: africompta
+version: !ruby/object:Gem::Version
+  version: 1.9.8
+platform: ruby
+authors:
+- Linus Gasser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: qooxview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: With this module you can have a simple accounting-system
+email: ineiti@linusetviviane.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- TODO
+- Test/ac_account.rb
+- Test/ac_africompta.rb
+- Test/ac_big.rb
+- Test/ac_movement.rb
+- Test/ac_sqlite.rb
+- Test/config_test.yaml
+- Test/db.testGestion
+- Test/test.rb
+- VERSION
+- africompta.gemspec
+- lib/africompta.rb
+- lib/africompta/acaccess.rb
+- lib/africompta/acqooxview.rb
+- lib/africompta/africompta.rb
+- lib/africompta/entities/account.rb
+- lib/africompta/entities/acschemas.rb
+- lib/africompta/entities/movement.rb
+- lib/africompta/entities/remote.rb
+- lib/africompta/entities/users.rb
+- lib/africompta/views/edit/movement.rb
+- lib/africompta/views/edit/tabs.rb
+- lib/africompta/views/report/annual.rb
+- lib/africompta/views/report/tabs.rb
+homepage: https://github.com/ineiti/AfriCompta
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Africompta-module for QooxView
+test_files: []