gestion 1.9.12

data/Views/Person/Tabs.rb

@@ -0,0 +1,162 @@
+class PersonTabs < View
+  def layout
+    @order = 10
+    @update = true
+    @persons_total = Persons.data.count
+
+    gui_vbox :nogroup do
+      show_str :search
+      show_list_single :persons, '[]', :flexheight => 1, :callback => true
+      show_button :start_search, :delete, :add
+
+      gui_window :add_person do
+        show_str :complete_name, :width => 150
+        show_str :login_prop
+        #show_block :address
+        show_button :add_person, :close
+      end
+
+      gui_window :error do
+        show_html :info
+        show_button :close
+      end
+
+      gui_window :win_confirm_delete do
+        show_html :delete_txt
+        show_button :confirm_delete, :close
+      end
+    end
+  end
+
+  def rpc_update(session)
+    super(session)
+    #+ rpc_callback_search(session, {}, false)
+  end
+
+  def rpc_button_start_search(session, args)
+    rpc_callback_search(session, args)
+  end
+
+  def rpc_button_delete(session, args)
+    if session.can_view(:FlagDeletePerson)
+      if (p_login = args._persons) and
+          (p = Persons.match_by_login_name(p_login[0]))
+        dputs(3) { "Found person #{p.inspect} - #{p.class.name}" }
+        return reply(:window_show, :win_confirm_delete) +
+            reply(:update, :delete_txt => 'Are you sure you want to delete user<br>' +
+                             "#{p.login_name}:#{p.full_name} ?")
+      end
+    end
+  end
+
+  def rpc_button_confirm_delete(session, args)
+    if session.can_view(:FlagDeletePerson)
+      if (p_login = args._persons) and
+          (p = Persons.match_by_login_name(p_login[0]))
+        dputs(3) { "Found person #{p.inspect} - #{p.class.name}" }
+        begin
+          log_msg :Persons, "User #{session.owner.login_name} deletes #{p.login_name}"
+          p.delete
+        rescue IsNecessary => who
+          return reply(:window_hide) +
+              reply(:window_show, :error) +
+              reply(:update, :info => "Course #{who.for_course.name} " +
+                               "still needs #{p.login_name}")
+        end
+      end
+    end
+    reply(:window_hide) +
+        rpc_callback_search(session, args)
+  end
+
+  def rpc_update_view(session, args = nil)
+    login_prop = session.can_view(:FlagAdminLoginProp) ? :unhide : :hide
+    super(session, args) +
+        reply(:focus, :search) +
+        reply(session.can_view(:FlagPersonDelete) ? :unhide : :hide, :delete) +
+        reply(session.can_view(:FlagPersonAdd) ? :unhide : :hide, :add) +
+        reply(login_prop, :login_prop) +
+        reply(:fade_in, :parent)
+  end
+
+  def rpc_list_choice(session, name, args)
+    dputs(3) { "args is #{args.inspect}" }
+    dputs(3) { "New choice #{name} - #{args['persons']}" }
+
+    if name == 'persons' and args and args['persons']
+      reply(:pass_tabs, ['list_choice', name, {:persons => [args._persons]}]) +
+          reply(:fade_in, :parent_child)
+    else
+      []
+    end
+  end
+
+  def rpc_callback_search(session, data, do_list_choice = true)
+    dputs(3) { "Got data: #{data.inspect}" }
+
+    s = data._search
+
+    center = session.owner.permissions.index('center') ?
+        session.owner.login_name : nil
+    result = Persons.search_in(s, center: center)
+
+    ret = reply(:empty, :persons)
+
+    if result.length > 0
+      ret += reply(:update,
+                   :persons => result.collect { |p|
+                     p.to_list(session.owner) },
+                   :search => s)
+      if do_list_choice
+        ret += reply(:update, :persons => [result[0].login_name])
+      end
+    else
+      ret += reply(:fade_in, :parent) +
+          reply(:child, reply(:empty_nonlists))
+    end
+
+    ret + reply(:focus, :search)
+  end
+
+  def rpc_autofill(session, args)
+    ret = []
+    if args['persons'] and args['persons'].length > 0
+      p = Persons.match_by_login_name(args['persons'][0])
+      if args['search']
+        ret += rpc_callback_search(session, args, false)
+      else
+        ret += reply(:update, :persons => [p.to_list(session.owner)]) +
+            reply(:update, :search => p.login_name)
+      end
+      ret += reply(:update, :persons => [p.login_name])
+    elsif args['search']
+      ret += rpc_callback_search(session, args)
+    end
+    ret
+  end
+
+  def rpc_button_close(session, data)
+    reply(:window_hide)
+  end
+
+  def rpc_button_add(session, data)
+    reply(:window_show, :add_person) +
+        reply(:empty, [:complete_name, :login_prop]) +
+        reply(:hide, [:family_name, :first_name]) +
+        reply(:focus, :complete_name)
+  end
+
+  def rpc_button_add_person(session, data)
+    data.to_sym!
+    dputs(3) { "Pressed button accept with #{data.inspect}" }
+    person = Persons.create_person(data._complete_name, session.owner,
+                                   data._login_prop)
+    #person.data_set_hash(data.reject { |k, v|
+    #  k =~ /(family_name|first_name|login_name|person_id)/ })
+
+    reply(:window_hide) +
+        rpc_callback_search(session, 'search' => person.login_name)
+    #reply( :child, reply( :switch_tab, :PersonModify ) ) +
+  end
+
+end

data/Views/Report/ComptaExecutive.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

data/Views/Report/ComptaFlat.rb

@@ -0,0 +1,79 @@
+class ReportComptaFlat < View
+  def layout
+    @count = 1
+    @rpc_update = true
+    @order = 30
+    @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
+      end
+      gui_vbox :nogroup do
+        show_int :total
+        show_str :desc, :width => 300
+        show_button :account_update, :report_movements
+      end
+      gui_window :get_report do
+        show_html :txt
+        show_button :close
+      end
+    end
+  end
+
+  def rpc_button_report_movements(session, data)
+    if acc = data._account_list
+      dputs(3) { "Got account #{acc.path}" }
+      file = "/tmp/report_movs_#{@count += 1}.pdf"
+      acc.print_pdf(file, true)
+      reply(:window_show, :get_report) +
+          reply(:update, :txt => 'Get the report:<br>' +
+              "<a href='#{file}' target='other'>#{file}</a>")
+    end
+  end
+
+  def rpc_button_account_update(session, data)
+    if (acc = data._account_list).class == Account
+      acc.update_total
+    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)
+    if (acc = data._account_list) != []
+      reply(:update, :total => acc.total_form) +
+          reply(:update, :desc => acc.desc)
+    else
+      []
+    end
+  end
+
+  def rpc_list_choice_account_archive(session, data)
+    update_list(data._account_archive)
+  end
+end

data/Views/Report/ReportCourse.rb

@@ -0,0 +1,47 @@
+# Allows for adding cash to a specific course
+
+class ReportCourse < View
+  include PrintButton
+  
+  def layout
+    @order = 10
+    @update = true
+    @functions_need = [:cashbox, :accounting]
+
+    gui_hboxg do
+      gui_vboxg :nogroup do
+        show_entity_course :course, :single, :name, 
+          lambda{|c| c.entries}, :callback => true, :flexheight => 1
+        show_print :print
+      end
+      gui_vbox :nogroup do
+        show_table :report, :headings => [ :Date, :Desc, :Amount, :Rest ],
+          :widths => [ 100, 200, 75, 75 ], :height => 400, :width => 470,
+          :columns => [0, 0, :align_right, :align_right]
+      end
+      
+      window_print_status
+    end
+  end
+  
+  def rpc_update( session )
+    super( session ) +
+      reply( :empty_nonlists, :course ) +
+      reply( :update, :course => Courses.list_courses_entries(session) ) +
+      reply_print( session )
+  end
+  
+  def rpc_button_print( session, data )
+    send_printer_reply( session, :print, data,
+      data._course.report_pdf )
+  end
+  
+  def rpc_list_choice_course( session, data )
+    dputs(3){"report is #{data._report_start.inspect}"}
+    ret = reply( :empty, :report )
+    
+    if data._course != []
+      ret += reply( :update, :report => data._course.report_list )
+    end
+  end
+end

data/Views/Report/Tabs.rb

@@ -0,0 +1,8 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class ReportTabs < View
+  def layout
+    @order = 100
+  end
+end

data/Views/Report/Usage.rb

@@ -0,0 +1,52 @@
+class ReportUsage < View
+
+  def layout
+    @order = 60
+    @update = true
+    @functions_need = [:usage_report]
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        show_entity_usage_all :usage, :single, :name, :callback => true
+        show_button :print
+      end
+      gui_vbox :nogroup do
+        show_table :usage_report, :headings => [:Element, :Count],
+                   :widths => [300, 70], :height => 300
+        show_list_drop :duration, '[[1, :day],[7, :week], [14, :bi_week],' +
+            ' [31,:month], [365, :year]]', :callback => true
+        show_date :from
+        show_date :to
+        show_button :update
+      end
+    end
+  end
+
+  def rpc_update(session)
+    reply(:update, {from: (Date.today - 7).to_web, to: Date.today.to_web,
+                    duration: [7]})
+  end
+
+  def rpc_print(session, name, data)
+
+  end
+
+  def rpc_list_choice_usage(session, data)
+    return [] unless data._usage
+    table = data._usage.collect_data(data._from.date_from_web,
+                                     data._to.date_from_web)
+    reply(:empty, :usage_report) +
+        reply(:update, {:usage_report => table,
+                        from: data._from, to: data._to})
+  end
+
+  def rpc_list_choice_duration(session, data)
+    return [] if !data._to or !data._duration.first or !data._usage
+    data._from = (data._to.date_from_web - data._duration.first.to_i).to_web
+    rpc_list_choice_usage(session, data)
+  end
+
+  def rpc_button_update(session, data)
+    rpc_list_choice_usage(session, data)
+  end
+end

data/Views/Report/UsageCases.rb

@@ -0,0 +1,59 @@
+class ReportUsageCases < View
+  include VTListPane
+
+  def layout
+    @order = 50
+    @update = true
+    @functions_need = [ :usage_report ]
+
+    set_data_class :Usages
+
+    gui_vbox do
+      gui_hbox :nogroup do
+        gui_vbox :nogroup do
+          vtlp_list :usage_list, 'name'
+          #show_entity_usage_all :usage, :single, :name, :callback => true,
+          #                  :flexheight => 1
+          show_button :delete, :new
+        end
+        gui_vbox :nogroup do
+          show_str :name
+          show_str :file_dir
+          show_str :file_glob
+          show_text :file_filter, :flexwidth => 1, :flexheight => 1
+          show_button :save
+        end
+      end
+      gui_vboxg :nogroup do
+        show_list_drop :file_data, '%w(none)', :callback => :file_chosen
+        show_text :file_source, :flexwidth => 1, :flexheight => 1
+        show_text :file_filtered, :flexwidth => 1, :flexheight => 1
+      end
+    end
+  end
+  
+  def rpc_list_choice_file_data( session, data )
+    file_data = data._file_data.first
+    return if file_data == 'none'
+    usage_list = Usages.match_by_id( data._usage_list.first ) or return
+    file_f = [{}]
+    file_s = if File.exists? file_data.to_s
+               file_f = usage_list.filter_file( file_data )
+               File.open( file_data, 'r').readlines[0..100]
+             else
+               ''
+             end
+    reply( :empty, %w( file_source file_filtered ) ) +
+        reply( :update, :file_source => file_s ) +
+        reply( :update, :file_filtered => file_f[0..100].join("\n"))
+  end
+
+  def rpc_update(session)
+    reply(:empty, :file_data) +
+        if ul = Usages.match_by_id(session.s_data._usage_list)
+          reply(:update, :file_data => ul.fetch_files)
+        else
+          []
+        end
+  end
+end

data/Views/Self/Cash.rb

@@ -0,0 +1,67 @@
+class SelfCash < View
+  def layout
+    set_data_class :Persons
+    @update = true
+    @cache_payments = {}
+    @order = 20
+    @functions_need = [:accounting]
+    @visible = false
+
+    gui_vbox do
+        show_int_ro :account_total_due, :width => 100
+        show_list_single :payments, :width => 500, :callback => true,
+          :nopreselect => true, :flexheight => 1
+        show_button :update
+    end
+  end
+
+  def rpc_update( session, client = nil )
+    person = session.owner
+    reply( :empty_nonlists, %w( payments ) ) +
+      reply( :update, { :account_total_due => person.account_total_due } ) +
+      reply( :update, { :payments => list_payments( session, true ) } )
+  end
+
+  def list_payments( session, force = false )
+    dputs(3){"list_payments #{session.inspect}"}
+    person = session.owner
+    pid = person.person_id
+    if not @cache_payments[pid] or force
+      @cache_payments[pid] = if ad = person.account_due
+        dputs(3){"account_due is here"}
+        ad.movements.select{|m| m.value != 0}.collect{|m|
+          dputs(4){"Collecting #{m.inspect}"}
+          "#{m.date} :: #{( m.value * 1000 ).floor.to_s.rjust(6,'_')} " + 
+              ":: #{m.desc}"
+        }
+      else
+        ""
+      end
+    end
+    dputs(3){"Found movements #{@cache_payments[pid].inspect}"}
+    @cache_payments[pid]
+  end
+
+  def rpc_list_choice( session, name, args )
+    if desc = args['payments']
+      desc = desc[0]
+      dputs( 2 ){ "New choice #{name} - #{args.inspect}" }
+      if desc =~ /.*Gestion: internet_credit/
+        login = desc.sub(/.*internet_credit pour -([^:]*).*/, '\1')
+    
+        reply( :parent, 
+          reply( :init_values, [ :PersonTabs, { :search => login, :persons => [] } ] ) +
+            reply( :switch_tab, :PersonTabs ) ) +
+          reply( :switch_tab, :PersonModify )
+      end
+      #reply( :parent, reply( :update, :search => login) )
+      #reply( :parent, View.PersonTabs.rpc_callback_search( session, 
+      #  "search" => login ) )
+    end
+  end
+  
+  def rpc_button_update( session, data)
+    rpc_update( session )
+  end
+
+end