africompta 1.9.10 → 1.9.11

data/lib/africompta/views/compta/edit_accounts.rb

@@ -0,0 +1,138 @@
+class ComptaEditAccounts < View
+  def layout
+    @rpc_update = true
+    @order = 200
+    @functions_need = [:accounting]
+
+    gui_hboxg do
+      gui_vboxg :nogroup do
+        show_entity_account :account_archive, :drop, :callback => true
+        show_entity_account :account_list, :single,
+                            :width => 400, :flex => 1, :callback => true
+        show_button :delete, :new
+      end
+      gui_vbox :nogroup do
+        show_str :name
+        show_str :desc, :width => 300
+        show_list_drop :multiplier, '%w(passive active)'
+        show_list_drop :keep_total, '%w(true false)'
+        show_button :save, :account_update
+      end
+
+      gui_window :account_new do
+        show_str :name_new, :width => 300
+        show_str :desc_new
+        show_list_drop :multiplier_new, '%w(passive active)'
+        show_list_drop :keep_total_new, '%w(true false)'
+        show_button :add_account, :close
+      end
+
+      gui_window :msg_win do
+        show_html :msg
+        show_button :close
+      end
+    end
+  end
+
+  def rpc_button_account_update(session, data)
+    if (acc = data._account_list).class == Account
+      acc.update_total
+    end
+  end
+
+  def set_mult_keep(acc, mult, keep)
+    acc.multiplier = mult.first == 'active' ? -1 : 1
+    acc.keep_total = keep.first == 'true'
+  end
+
+  def get_mult_keep(acc)
+    [acc.multiplier == -1 ? 'active' : 'passive',
+     acc.keep_total ? 'true' : 'false']
+  end
+
+  def rpc_button_save(session, data)
+    if (acc = data._account_list).class == Account
+      acc.desc, acc.name = data._desc, data._name
+      set_mult_keep(acc, data._multiplier, data._keep_total)
+      update_list
+    end
+  end
+
+  def rpc_button_new(session, data)
+    if (acc = data._account_list).class == Account
+      mult, keep = get_mult_keep(acc)
+      reply(:window_show, :account_new) +
+          reply(:empty, %w( name_new desc_new )) +
+          reply(:update, multiplier_new: [mult]) +
+          reply(:update, keep_total_new: [keep])
+    else
+      reply(:window_show, :msg_win) +
+          reply(:update, :msg => "Choisir un compte parent d'abord")
+    end
+  end
+
+  def rpc_button_add_account(session, data)
+    if (acc = data._account_list).class == Account
+      return unless data._name_new.to_s.length > 0
+      new_acc = Accounts.create(data._name_new, data._desc_new, acc)
+      set_mult_keep(new_acc, data._multiplier_new, data._keep_total_new)
+      update_list(data._account_archive) +
+          reply(:update, :account_list => new_acc.id) +
+          reply(:window_hide)
+    end
+  end
+
+  def rpc_button_delete(session, data)
+    if (acc = data._account_list).class == Account
+      if acc.is_empty
+        acc.delete
+        update_list(data._account_archive)
+      else
+        reply(:window_show, :msg_win) +
+            reply(:update, msg: "The account #{acc.name} is not empty!")
+      end
+    end
+  end
+
+  def update_list(account = [])
+    account.class == Account or account = AccountRoot.current
+
+    reply(:empty_nonlists, :account_list) +
+        reply(:update, :account_list => account.listp_path)
+  end
+
+  def update_archive
+    reply(:empty_nonlists, :account_archive) +
+        reply(:update_silent, :account_archive => [[0, "Actual"]].concat(
+                                if archive = AccountRoot.archive
+                                  archive.accounts.collect { |a|
+                                    [a.id, a.path] }.sort_by { |a| a[1] }
+                                else
+                                  []
+                                end))
+  end
+
+  def rpc_update_view(session)
+    super(session) +
+        update_list +
+        update_archive
+  end
+
+  def rpc_list_choice_account_list(session, data)
+    reply(:empty_nonlists) +
+        if (acc = data._account_list) != []
+          mult, kt = get_mult_keep(acc)
+          reply(:update, {total: acc.total_form,
+                          desc: acc.desc,
+                          name: acc.name,
+                          multiplier: [mult],
+                          keep_total: [kt]})
+        else
+          []
+        end
+  end
+
+  def rpc_list_choice_account_archive(session, data)
+    update_list(data._account_archive)
+  end
+end

data/lib/africompta/views/compta/edit_movements.rb

@@ -0,0 +1,167 @@
+class ComptaEditMovements < View
+
+  def layout
+    @rpc_update = true
+    @order = 100
+    @functions_need = [:accounting]
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        show_entity_account :account_archive, :drop, :callback => true
+        show_entity_account :account_src, :drop,
+                            :width => 400, :callback => true
+        show_table :movement_list, :headings => [:Date, :Description, :Account, :Sub, :Total],
+                   :widths => [80, 300, 200, 75, 75], :height => 400,
+                   :columns => [:align_right, 0, :align_right, :align_right],
+                   :callback => :edit,
+                   :edit => [0, 1, 3]
+        show_button :edit, :delete, :new
+      end
+
+      gui_window :movement_edit do
+        show_entity_account :account_dst, :drop, :width => 400
+        show_str :desc, :width => 300
+        show_int :value
+        show_date :date
+        show_button :save, :new_mov, :close
+      end
+    end
+  end
+
+  def rpc_button_new_mov(session, data)
+    if (acc_src = data._account_src).class == Account &&
+        (acc_dst = data._account_dst).class == Account
+      value = to_money(data._value)
+      Movements.create(data._desc, Date.from_web(data._date), value / 1000.0,
+                       acc_src, acc_dst)
+      reply(:window_hide) +
+          update_list(data._account_archive, data._account_src)
+    end
+  end
+
+  def rpc_button_save(session, data)
+    if (mov = Movements.match_by_id(data._movement_list.first._element_id)).class == Movement
+      value = to_money(data._value)
+      mov.desc, mov.value, mov.date =
+          data._desc, value / 1000.0, Date.from_web(data._date)
+
+      old = mov.get_other_account(data._account_src)
+      dputs(3) { "Old account: #{old.get_path} - new account: #{data._account_dst.get_path}" }
+      if old != data._account_dst
+        mov.move_from_to(old, data._account_dst)
+      end
+
+      reply(:window_hide) +
+          update_list(data._account_archive, data._account_src)
+    end
+  end
+
+  def rpc_button_edit(session, data)
+    if (mov = Movements.match_by_id(data._movement_list.first._element_id)).class == Movement
+      other = mov.get_other_account(data._account_src).id
+      reply(:window_show, :movement_edit) +
+          reply(:update, :desc => mov.desc, :value => (mov.value*1000).to_i,
+                :date => mov.date.to_web, :account_dst => [other]) +
+          reply_show_hide(:save, :new_mov)
+    end
+  end
+
+  def rpc_button_new(session, data)
+    reply(:window_show, :movement_edit) +
+        reply(:empty, %w( desc value )) +
+        reply(:update, :date => Date.today.to_web) +
+        reply_show_hide(:new_mov, :save)
+  end
+
+  def rpc_button_delete(session, data)
+    if (mov = Movements.match_by_id(data._movement_list.first._element_id)).class == Movement
+      mov.delete
+      update_list(data._account_archive, data._account_src)
+    end
+  end
+
+  def update_list(archive = nil, account = nil)
+    if !(archive && account)
+      return reply(:empty_nonlists, [:movement_list, :account_src]) +
+          if archive
+            reply(:update_silent, account_src: archive.listp_path) +
+                reply(:update_silent, account_dst: archive.listp_path)
+          else
+            []
+          end
+    end
+
+    total = account.movements.inject(0.0) { |sum, m|
+      sum + (m.get_value(account) * 1000).round
+    }.to_i
+    reply(:empty_nonlists, :movement_list) +
+        reply(:update, :movement_list => account.movements.collect { |m|
+                       value = (m.get_value(account) * 1000).to_i
+                       total_old = total
+                       total -= value
+                       other = m.get_other_account(account).get_path
+                       m.date ||= Date.today
+                       [m.id, [m.date.to_web, m.desc, other, value.separator,
+                               total_old.separator]]
+                     })
+  end
+
+  def update_accounts()
+    reply(:empty_nonlists, [:account_archive, :account_src, :account_dst]) +
+        reply(:update_silent, :account_archive =>
+                                [[AccountRoot.actual.id, 'Actual']].concat(
+                                    if archive = AccountRoot.archive
+                                      archive.accounts.collect { |a|
+                                        [a.id, a.path] }.sort_by { |a| a[1] }
+                                    else
+                                      []
+                                    end)) +
+        update_list(AccountRoot.actual, AccountRoot.actual) +
+        reply(:update, :account_src => AccountRoot.actual.listp_path,
+              :account_dst => AccountRoot.actual.listp_path)
+  end
+
+  def rpc_update_view(session)
+    super(session) +
+        update_list +
+        update_accounts
+  end
+
+  def rpc_update(session)
+    reply(:update, :date => Date.today.to_web)
+  end
+
+  def rpc_list_choice_account_src(session, data)
+    return if data._account_src == []
+    update_list(data._account_archive, data._account_src)
+  end
+
+  def rpc_list_choice_account_archive(session, data)
+    return if data._account_archive == []
+    update_list(data._account_archive)
+  end
+
+  def rpc_list_choice_movement_list(session, data)
+    if (mov = data._movement_list).class == Movement
+      reply(:update, :desc => mov.desc, :value => (mov.value * 1000).to_i,
+            :date => mov.date.to_web)
+    end
+  end
+
+  def rpc_table_movement_list(session, data)
+    ml = data._movement_list.first
+    dst = Accounts.get_by_path(ml._Account)
+    rpc_button_save(session, data.merge('value' => ml._Sub, 'desc' => ml._Description,
+                           'date' => ml._Date, 'account_dst' => dst))
+    #if (mov = Movements.match_by_id(data._movement_list.first)).class == Movement
+    #  rpc_button_edit(session, data)
+    #end
+  end
+
+  # Delete all non-number characters, but also accept european
+  # 10,5 == 10.5
+  def to_money(str)
+    return str.delete('^0123456789.,-').gsub(/,/, '.').to_f
+  end
+end
+

data/lib/africompta/views/compta/remotes.rb

@@ -0,0 +1,23 @@
+class ComptaRemotes < View
+  include VTListPane
+  def layout
+    @order = 500
+    
+    set_data_class :Remotes
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        vtlp_list :remotes_list, 'url', width: 250, maxheight: 250
+        show_button :new
+      end
+      gui_vbox :nogroup do
+        show_str :url, width: 250
+        show_str :name
+        show_str :pass
+        show_int :account_index
+        show_int :movement_index
+        show_button :save
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class ComptaTabs < View
+  def layout
+    @order = 90
+    @functions_need = [:accounting]
+  end
+end

data/lib/africompta/views/compta/users.rb

@@ -0,0 +1,23 @@
+class ComptaUsers < View
+  include VTListPane
+  def layout
+    @order = 600
+    
+    set_data_class :Users
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        vtlp_list :users_list, 'name', :width => 150, :maxheight => 250
+        show_button :new
+      end
+      gui_vbox :nogroup do
+        show_str :name
+        show_str :full
+        show_str :pass
+        show_int :account_index
+        show_int :movement_index
+        show_button :save
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+class ReportComptaExecutive < View
+  include PrintButton
+
+  def layout
+    @order = 20
+    @update = true
+    @functions_need = [:accounting]
+
+    gui_hboxg do
+      gui_vbox :nogroup do
+        gui_vboxg :nogroup do
+          show_entity_report_all :reports, :single, :name, :callback => true,
+                                 :flexheight => 1
+          show_button :report_add, :report_delete
+        end
+        gui_vbox :nogroup do
+          show_date :start
+          show_int :months
+          show_print :print
+        end
+      end
+      gui_vboxg :nogroup do
+        show_str :name
+        show_entity_reportAccount :accounts, :single,
+                                  :flexheight => 1, :width => 300
+        show_button :account_add, :account_del, :account_edit
+        show_button :account_up, :account_down
+      end
+
+      gui_window :win_account do
+        gui_vbox :nogroup do
+          show_entity_account :root, :drop, :width => 400,
+                              :callback => true
+          show_entity_account :account, :drop
+          show_int :level
+          show_button :account_add_win, :account_save_win, :close
+        end
+      end
+
+      gui_window :win_report do
+        show_str :report_name
+        show_button :report_add_win, :close
+      end
+
+      gui_window :progress do
+        show_html :progress_txt
+        show_button :report_cancel
+      end
+
+      window_print_status
+    end
+  end
+
+  def rpc_button_report_add(session, data)
+    reply(:window_show, :print_status)
+  end
+
+  def update_account(root = AccountRoot.actual, account = nil)
+    reply(:empty, :account) +
+        reply(:update, :account => root.listp_path) +
+        reply(:update, :account => [(account.class == Account) ? account.id : 0])
+  end
+
+  def update_root(root = AccountRoot.actual)
+    roots = [[AccountRoot.actual.id, 'Actual']]
+    archive = AccountRoot.archive and roots.concat(archive.listp_path(1)[1..-1])
+    reply(:empty, :root) +
+        reply(:update_silent, :root =>
+                                roots.concat([(root.class == Account) ? root.id : 0]))
+  end
+
+  def update_reports
+    reply(:empty, :reports) +
+        reply(:update, :reports => Reports.listp_name)
+  end
+
+  def update_report(report, account = nil)
+    reply(:empty, :accounts) +
+        reply(:update, :name => report.name) +
+        reply(:update, :accounts => report.listp_accounts) +
+        reply(:update, :accounts => (account.class == ReportAccount) ?
+                         [account.id] : nil)
+  end
+
+  def rpc_update(session)
+    td = Date.today
+    # Start in beginning of semester
+    start = Date.new(td.year, (td.month / 7.0).floor * 6 + 1)
+    update_reports +
+        reply(:update, :start => start.to_web) +
+        reply(:update, :months => 6) +
+        reply_print(session)
+  end
+
+  def button_account(session, name, data)
+    return if data._reports == []
+
+    case name
+      when /add_win/
+        data._reports.accounts = data._reports.accounts +
+            [ReportAccounts.create(data)]
+        update_report(data._reports) +
+            reply(:window_hide)
+      when /add/
+        reply(:window_show, :win_account) +
+            update_account +
+            update_root +
+            reply(:update, :level => "1") +
+            reply_show_hide(:account_add_win, :account_save_win)
+      when /del/
+        return if data._accounts == []
+        data._reports.accounts = data._reports.accounts.reject { |a|
+          a == data._accounts
+        }
+        update_report(data._reports)
+      when /edit/
+        return if data._accounts == []
+        reply(:window_show, :win_account) +
+            update_root(data._accounts.root) +
+            update_account(data._accounts.root, data._accounts.account) +
+            reply(:update, :level => data._accounts.level) +
+            reply_show_hide(:account_save_win, :account_add_win)
+      when /save_win/
+        data._accounts.data_set_hash(data)
+        update_report(data._reports) +
+            reply(:window_hide)
+      when /up/
+        accs = data._reports.accounts
+        if (index = accs.index(data._accounts)) > 0
+          accs[index - 1], accs[index] = accs[index], accs[index - 1]
+        end
+        data._reports.accounts = accs
+        update_report(data._reports, data._accounts)
+      when /down/
+        accs = data._reports.accounts
+        if (index = accs.index(data._accounts)) < accs.length - 1
+          accs[index + 1], accs[index] = accs[index], accs[index + 1]
+        end
+        data._reports.accounts = accs
+        update_report(data._reports, data._accounts)
+    end
+  end
+
+  def button_report(session, name, data)
+    case name
+      when /add_win/
+        if data._report_name.to_s.length > 0
+          Reports.create(:name => data._report_name, :accounts => [])
+        end
+        reply(:window_hide) +
+            update_reports
+      when /add/
+        reply(:window_show, :win_report) +
+            reply(:empty, :report_name)
+      when /del/
+        data._reports != [] and data._reports.delete
+        rpc_update(session)
+    end
+  end
+
+  def rpc_button(session, name, data)
+    case name
+      when /^account_(.*)/
+        button_account(session, $~[1], data)
+      when /^report_(.*)/
+        button_report(session, $~[1], data)
+      when /print/
+        if data._reports.class == Report
+          start_thread(session, data)
+          reply(:auto_update, -1) +
+              reply(:update, progress_txt: 'Starting checking') +
+              reply(:window_show, :progress) +
+              rpc_print(session, :print, data)
+        end
+      when /close/
+        reply(:window_hide)
+      when /report_cancel/
+        dputs(2){ "Killing thread #{session.s_data._report_ce_thread}"}
+        if thr = session.s_data._report_ce_thread
+          thr.kill
+        end
+        reply(:window_hide) +
+            reply(:auto_update, 0)
+    end
+  end
+
+  def start_thread(session, data)
+    session.s_data._report_ce = nil
+    session.s_data._report_ce_thread = Thread.start {
+      System.rescue_all do
+        session.s_data._report_ce = data._reports.print_pdf_monthly(
+            Date.from_web(data._start), data._months.to_i)
+      end
+      dputs(2){ 'Thread finished'}
+    }
+  end
+
+  def rpc_update_with_values(session, data)
+    report = data._reports
+    if report_ce = session.s_data._report_ce
+      return reply(:window_hide) +
+          reply(:auto_update, 0) +
+          send_printer_reply(session, :print, data, report_ce)
+    else
+      return reply(:update, :progress_txt =>
+                              "Accounts done: #{(report.print_accounts * 100).floor}%<br>" +
+                                  "Calculating: #{report.print_account}")
+    end
+  end
+
+  def rpc_list_choice_reports(session, data)
+    return if data._reports == []
+    reply(:empty, :accounts) +
+        update_report(data._reports)
+  end
+
+  def rpc_list_choice_root(session, data)
+    return if data._root == []
+    update_account(data._root)
+  end
+end